Asymptotes: Why?

1 / 11

# Asymptotes: Why? - PowerPoint PPT Presentation

Asymptotes: Why?. How to describe an algorithm’s running time? (or space, …). How does the running time depend on the input? T(x) = running time for instance x. Problem: Impractical to use, e.g., “15 steps to sort [3 9 1 7], 13 steps to sort [1 2 0 3 9], …”

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about 'Asymptotes: Why?' - mills

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Asymptotes: Why?

How to describe an algorithm’s running time?

(or space, …)

How does the running time depend on the input?

T(x) = running time for instance x

Problem: Impractical to use, e.g.,

“15 steps to sort [3 9 1 7], 13 steps to sort [1 2 0 3 9], …”

Need to abstract away from the individual instances.

Asymptotes: Why?

Standard solution: Abstract based on size of input.

How does the running time depend on the input?

T(n) = running time for instances of size n

Problem: Time also depends on other factors.

E.g., on sortedness of array.

Asymptotes: Why?

Most common. Default.

Determining the input probability distribution can be difficult.

Solution: Provide a bound over these instances.

Worst case T(n) = max{T(x) | x is an instance of size n}

Best case T(n) = min{T(x) | x is an instance of size n}

Average case T(n) = |x|=n Pr{x}  T(x)

Asymptotes: Why?

Worst case T(n) = max{T(x) | x is an instance of size n}

Best case T(n) = min{T(x) | x is an instance of size n}

Average case T(n) = |x|=n Pr{x}  T(x)

Two different kinds of functions:

T(instance) T(size of instance)

Won’t use T(instance) notation again, so can ignore.

Asymptotes: Why?

Problem: T(n) = 3n2 + 14n + 27

Too much detail: constants may reflect implementation details & lower terms are insignificant.

Solution: Ignore the constants & low-order terms.(Omitted details still important pragmatically.)

3n2 > 14n+17

 “large enough” n

Upper Bounds

Creating an algorithm proves we can solve the problem within a given bound.

But another algorithm might be faster.

E.g., sorting an array.

Insertion sort  O(n2)

What are example algorithms for

O(1), O(log n), O(n), O(n log n), O(n2), O(n3), O(2n)?

Lower Bounds

Sometimes can prove that we cannot compute something without a sufficient amount of time.

That doesn't necessarily mean we know how to compute it in this lower bound.

E.g., sorting an array.

# comparisons needed in worst case  (n log n)

Shown in COMP 482.

Definitions: O, 

T(n)  O(g(n))

 constants C,k > 0

such that

 nk, T(n)  Cg(n)

T(n) (g’(n))

 constants C’,k’ > 0

such that

 nk’, T(n)  C’g’(n)

Cg(n)

T(n)

C’g’(n)

k

k’

Examples: O, 

2n+13  O( ? )

Also, O(n2), O(5n), … Can always weaken the bound.

O(n)

2n+13  ( ? )

(n), also (log n), (1), …

2n O(n) ? (n) ?

Given a C, 2n  Cn, for all but small n.

(n), not O(n).

nlog n O(n5) ?

No. Given a C, log n  C5, for all large enough n. Thus, (n5).

Definitions: 

T(n)  (g(n))

T(n)  O(g(n)) and T(n)  (g(n))

Ideally, find algorithms that are asymptotically as good as possible.

Notation

O(), (), () are sets of functions.

But common to abuse notation, writing

T(n) = O(…)