def: A worst-case complexity measure estimates the time required for the most timeconsuming

Transcription

1 Section 2.3 Complexity COMPLEXITY disambiguation: In the early 1960 s, Chaitin and Kolmogorov used complexity to mean measures of complicatedness. However, most theoretical computer scientists have used it in a jargon sense that means measures of resource consumption. def: Algorithmic time-complexity measures estimate the time or the number of computational steps required to execute an algorithm, given as a function of the size of the input. terminology: The resource for a complexity measure is implicitly time, unless space or something else is specified. def: A worst-case complexity measure estimates the time required for the most timeconsuming input of each size. def: An average-case complexity measure estimates the average time required for input of each size.

2 Chapter 2 ALGORITHMS and INTEGERS Example 2.3.1: In searching and sorting, complexity is commonly measures in terms of the number of comparisons, since total computation time is typically a multiple of that. Algorithm 2.1.1: Find Maximum Input: unsorted array of integers a 1,a 2,...,a n Output: largest integer in array {Initialize} max := a 1 For i := 2 to n If max <a i then max := a i Continue with next iteration of for-loop. Return (max) Big-Oh: Always takes n 1 comparisons. Time complexity is in O(n).

3 Section 2.3 Complexity Example 2.3.2: Algorithm 2.1.2: Unsorted Sequential Search Input: unsorted array of integers a 1,a 2,...,a n target value x Output: subscript of entry equal to target value, or 0 if not found {Initialize} i := 1 While i 2 and x a i i := i +1 If i n then loc := i else loc := 0 Return (loc) Worst case takes n comparisons. Average case takes n/2 comparisons. Target not in Array: Every case takes n comparisons. Big-Oh: Time complexity is in O(n).

4 Chapter 2 ALGORITHMS and INTEGERS Example 2.3.3: Algorithm 2.1.3: Sorted Sequential Search Input: sorted array of integers a 1,a 2,...,a n target value x Output: subscript of entry equal to target value, or 0 if not found {Initialize} i := 1 While i n and x<a i i := i +1 If (i n cand x = a i ) then loc := i else loc := 0 Return (loc) Worst case takes n comparisons. Average case takes n/2 comparisons. Big-Oh: Time complexity is in O(n).

5 Section 2.3 Complexity Example 2.3.4: Algorithm 2.1.4: Two-level Search Input: sorted array of integers a 1,a 2,...,a n target value x Output: subscript of entry equal to target value, or 0 if not found {Initialize} i := 10 {Find target sublist of 10 entries} While i 2 and x a i i := i +10 {Linear search target sublist of 10 entries} {Initialize} j := i 9 While j i and x<a j j := j +1 If (j n cand x + a j ) then loc := j else loc := 0 Return (loc) Worst case takes (n/10) + 10 comparisons. Big-Oh: Time complexity is in O(n).

6 Chapter 2 ALGORITHMS and INTEGERS To optimize the two-level search, minimize n/x + x as in differential calculus. n x 2 + 1=0 x = n Worst case takes 2 n comparisons. Big-Oh: Time complexity is in O( n). Increasing to k levels further decreases the execution time to O( k n), provided that k is not too large.

7 Section 2.3 Complexity Example 2.3.5: Algorithm 2.1.5: Binary Search Input: unsorted array of integers a 1,a 2,...,a n target value x Output: subscript of entry equal to target value, or 0 if not found {Initialize} left := 1; right := n While left <right mid := (left + right)/2 If x>a mid then left := mid else right := mid If x = a left then loc := left else loc := 0 Return (loc) Every case takes lg n comparisons. Big-Oh: Time complexity is in O(lg n).

8 Chapter 2 ALGORITHMS and INTEGERS COMPLEXITY JARGON def: A problem is solvable if it can be solved by an algorithm. Example 2.3.6: Alan Turing defined the halting problem to be that of deciding whether a computational procedure (e.g., a program) halts for all possible input. He proved that the halting problem is unsolvable. def: A problem is in class P if it is solvable by an algorithm that runs in polynomial time. def: A problem is tractable if it is in class P. def: A problem is in class NP if an algorithm can decide in polynomial time whether a putative solution is really a solution. Example 2.3.7: The problem of deciding whether a graph is 3-colorable is in class NP. It is believed not to be in class P.