Text Chapters 1, 2

Sorting ä Sorting Problem: ä Input: A sequence of n numbers ä Output: A permutation (reordering) of the input sequence such that: instance ä Algorithm: ä well-defined computational procedure that transforms input into output ä steps for the computer to follow to solve a problem

Insertion Sort Animation Finding a place for item with value 5 in position 1: Finding a place for item with value 5 in position 1: Swap item in position 0 with item in position 1.

Insertion Sort Animation Positions 0 through 1 are now in non-decreasing order.

Insertion Sort Animation Finding a place for item with value 1 in position 2: Finding a place for item with value 1 in position 2: Swap item in position 1 with item in position 2.

Insertion Sort Animation Finding a place for item with value 1: Finding a place for item with value 1: Swap item in position 0 with item in position 1. Positions 0 through 2 are now in non-decreasing order.

Insertion Sort Animation Finding a place for item with value 3 in position 3: Finding a place for item with value 3 in position 3: Swap item in position 2 with item in position 3.

Insertion Sort Animation Finding a place for item with value 3: Finding a place for item with value 3: Swap item in position 1 with item in position 2.

Insertion Sort Animation Positions 0 through 3 are now in non-decreasing order.

Insertion Sort Animation Finding a place for item with value 2 in position 4: Finding a place for item with value 2 in position 4: Swap item in position 3 with item in position 4.

Insertion Sort Animation Finding a place for item with value 2: Finding a place for item with value 2: Swap item in position 2 with item in position 3.

Insertion Sort Animation Finding a place for item with value 2: Finding a place for item with value 2: Swap item in position 1 with item in position 2.

Insertion Sort Animation Positions 0 through 4 are now in non-decreasing order.

Insertion Sort Animation Finding a place for item with value 6 in position 5: Finding a place for item with value 6 in position 5: Swap item in position 4 with item in position 5.

Insertion Sort Animation Positions 0 through 5 are now in non-decreasing order.

Insertion Sort Animation Finding a place for item with value 4 in position 6: Finding a place for item with value 4 in position 6: Swap item in position 5 with item in position 6.

Insertion Sort Animation Finding a place for item with value 4: Finding a place for item with value 4: Swap item in position 4 with item in position 5.

Insertion Sort Animation Positions 0 through 6 are now in non-decreasing order.

Insertion Sort Animation Finding a place for item with value 7 in position 7: Finding a place for item with value 7 in position 7: Swap item in position 6 with item in position 7.

Insertion Sort Animation Positions 0 through 7 are now in non-decreasing order.

Insertion Sort Animation Positions 0 through 7 are now in non-decreasing order.

Insertion Sort Animation Positions 0 through 7 are now in non-decreasing order.

Asymptotic Notation courtesy of Prof. Costello O(g(n)) is a set of functions, so we often say f(n) is in O(g(n)).

Asymptotic Notation (cont.) courtesy of Prof. Costello

Asymptotic Analysis Math fact sheet (courtesy of Prof. Costello) is on our web site.

Function Order of Growth O( ) upper bound  ( ) lower bound  ( ) upper & lower bound n 1 n lg(n) n lg 2 (n) 2n2n2n2n n5n5n5n5 lg(n) lg(n)lglg(n) n2n2n2n2 know how to use asymptotic complexity notation to describe time or space complexity know how to order functions asymptotically (behavior as n becomes large)

Types of Algorithmic Input Best-Case Input: of all possible algorithm inputs of size n, it generates the “best” result for Time Complexity: “best” is smallest running time for Time Complexity: “best” is smallest running time Best-Case Input Produces Best-Case Running Time Best-Case Input Produces Best-Case Running Time provides a lower bound on the algorithm’s asymptotic running time provides a lower bound on the algorithm’s asymptotic running time (subject to any implementation assumptions) (subject to any implementation assumptions) for Space Complexity: “best” is smallest storage for Space Complexity: “best” is smallest storage Average-Case Input Worst-Case Input these are defined similarly Best-Case Time <= Average-Case Time <= Worst-Case Time

Bounding Algorithmic Time (using cases) n 1 n lg(n) n lg 2 (n) 2n2n2n2n n5n5n5n5 lg(n) lg(n)lglg(n) n2n2n2n2 T(n) =  (1) T(n) =  (2 n ) very loose bounds are not very useful! Worst-Case time of T(n) =  (2 n ) tells us that worst-case inputs cause the algorithm to take at most exponential time (i.e. exponential time is sufficient). But, can the algorithm every really take exponential time? (i.e. is exponential time necessary?) If, for arbitrary n, we find a worst-case input that forces the algorithm to use exponential time, then this tightens the lower bound on the worst-case running time. If we can force the lower and upper bounds on the worst-case time to match, then we can say that, for the worst-case running time, T(n) =  ( 2 n ) (i.e. we’ve found the minimum upper bound, so the upper bound is tight.) Using “case” we can discuss lower and/or upper bounds on: best-case running time or average-case running time or worst-case running time

Bounding Algorithmic Time (tightening bounds) n 1 n lg(n) n lg 2 (n) 2n2n2n2n n5n5n5n5 lg(n) lg(n)lglg(n) n2n2n2n2 T B (n) =  (1) T W (n) =  (2 n ) for example... 1st attempt T B (n) =  (n) 1st attempt 2nd attempt T W (n) =  (n 2 ) Here we denote best-case time by T B (n); worst-case time by T W (n) T B (n) =  (n) 2nd attempt 1st attempt T W (n) =  (n 2 ) Algorithm Bounds

Know the Difference!  (n) 1 2n2n2n2n O(n 5) worst-case bounds on problem on problem An inefficient algorithm for the problem might exist that takes this much time, but would not help us. No algorithm for the problem exists that can solve it for worst-case inputs in less than linear time. Strong Bound: A worst- case lower bound on a problem holds for every algorithm that solves the problem and abides by the problem’s assumptions. Weak Bound: A worst-case upper bound on a problem comes from just considering one algorithm. Other, less efficient algorithms that solve this problem might exist, but we don’t care about them! Both the upper and lower bounds could be loose (i.e. perhaps could be tightened later on).