Algorithm Analysis. Algorithm Efficiency Best, Worst, Average Cases Asymptotic Analysis (Big Oh) Space Complexity

Size: px

Start display at page:

Download "Algorithm Analysis. Algorithm Efficiency Best, Worst, Average Cases Asymptotic Analysis (Big Oh) Space Complexity"

Kellie Simpson
5 years ago
Views:

1 Algorithm Analysis Algorithm Efficiency Best, Worst, Average Cases Asymptotic Analysis (Big Oh) Space Complexity ITCS 2214:Data Structures 1 Mathematical Fundamentals

2 Measuring Algorithm Efficiency Empirical comparison (run programs) - has difficulties: Programming effort Implementation differences Exhaustive testing infeasible At best, want to keep 1 implementation Asymptotic Algorithm Analysis. Measure efficiency as a function of input size. ITCS 2214:Data Structures 2 Mathematical Fundamentals

3 Measuring Algorithm Efficiency Critical resources: Running time. Space (disk, RAM). Programmer s effort. Ease of use (user s effort). Running time depends on Machine load. OS, Compiler. Problem size. Input values. For most algorithms, running time, T (n) depends on some function of size n, of the input. T (n) f(n) ITCS 2214:Data Structures 3 Mathematical Fundamentals

4 Examples of Growth Rate Example 1:Largest Number in an Array static int largest(int[] array) { // Find largest val int currlargest = 0; // Store largest val for (int i=0; i<array.length; i++) if (array[i] > currlargest) // if largest currlargest = array[i]; // remember it } Analysis return currlargest; Basic Operation: Examine a single integer (Cost = c). Size: length of the array (n). T (n) = cn // Return largest val ITCS 2214:Data Structures 4 Mathematical Fundamentals

5 Examples of Growth Rate Example 2: An assignment of the first element of an array Example 3: Summing up the elements of an n n matrix. Example 4: Matrix multiplication Example 5: Inner Product of two vectors of length n ITCS 2214:Data Structures 5 Mathematical Fundamentals

6 Growth Rates ITCS 2214:Data Structures 6 Mathematical Fundamentals

7 Growth Rates ITCS 2214:Data Structures 7 Mathematical Fundamentals

8 Best, Worst and Average Cases Not all inputs of a given size take the same time Example:Searching for an element in an array Can be the first element (Best Case) Can be the last element (Worst Case) On the average, search half the elements(average Case) Issues/Applications Best Case: Not very likely, too optimistic Worst Case: Real time applications (air traffic control) Average Case: Assumes uniform distribution (equal likelihood) ITCS 2214:Data Structures 8 Mathematical Fundamentals

9 Asymptotic Analysis: Big-oh Definition: T n is in the set O(f(n)) if there exist two positive constants c and n 0 such that T (n) c f(n), for all n > n 0. For all data sets (i.e., n > n 0 ), the algorithm always executes in less than c f(n) steps (in best, average or worst case). Big-oh provides an Upper Bound Prefer the tightest upper bound: T n O(n 2 ). = 3n 2 is in O(n 3 ), but prefer ITCS 2214:Data Structures 9 Mathematical Fundamentals

10 Big-oh Example Example 1: Finding value X in an array T n = c s n/2 (average case). For all values of n > 1, c s.n/2 c s.n Therefore, by definition, T n is in O(n) for n 0 = 1, c = c s. ITCS 2214:Data Structures 10 Mathematical Fundamentals

11 Big-oh Example Example 2 (Average Case) T n = c 1 n 2 + c 2 n, in average case c 1 n 2 + c 2 n c 1 n 2 + c 2 n 2 (c 1 + c 2 )n 2, n > 1 Therefore, T n T n cn 2, for c = c 1 + c 2, n 0 = 1., and O(n 2 ), by definition Example 3 T n = c We say T n O(1). ITCS 2214:Data Structures 11 Mathematical Fundamentals

12 Definition: Big-Omega Notation T n is in the set Ω(g(n) if there exist two positive constants c and n 0 such that T n cg(n) for all n > n 0. For all data sets big enough (i.e., n > n 0 ), the algorithm always executes in more than cg(n) steps. Big Omega provides a lower bound. Always want greatest lower bound. Example T n = c 1 n 2 + c 2 n c 1 n 2 + c 2 n c 1 n 2, n > 1 T n cn 2, for c = c 1, n 0 = 1. Therefore, T n is in Ω(n 2 ) by definition. ITCS 2214:Data Structures 12 Mathematical Fundamentals

13 Big-Theta Notation When Big-Oh and Ω meet, we indicate using Θ (Big-Theta) notation. Definition An algorithm is said to be Θ(h(n)) if it is in O(h(n)) and it is in Ω(h(n)). For polynomial equations on T n, we always have Θ. Simplifying Rules 1. If f(n) is in O(g(n) and g(n) is in O(h(n), then f(n) is in O(h(n) 2. If f(n) is in O(kg(n)) for any constant k > 0, then f(n) is in O(g(n) 3. If f 1 (n) is in O(g 1 (n)) and f 2 (n) is in O(g 2 (n)), then (f 1 + f 2 )(n) is in O(max(g 1 (n), g 2 (n))). 4. If f 1 (n) is in O(g 1 (n)) and f 2 (n) is in O(g 2 (n)) then f 1 (n)f 2 (n) is in O(g 1 (n)g 2 (n)). ITCS 2214:Data Structures 13 Mathematical Fundamentals

14 Running Time of a Program Example 1: Assignment Example 2: Single Loop Example 3: Double Loop Example 4: Multiple double loops Example 5: Multiple double loops ITCS 2214:Data Structures 14 Mathematical Fundamentals

15 Binary Search static int bsearch(int K, int[] array, int left, int right) { // Return position in array (if any) with value K int l = left-1; int r = right+1; // l and r are beyond array bounds while (l+1!= r) // Stop when l and r meet { int i = (l+r)/2; // Look at middle of subarray } if (K < array[i]) r = i; // In left half if (K == array[i]) return i; // Found it if (K > array[i]) l = i; // In right half } return UNSUCCESSFUL; // Search value not in array Analysis: How many elements can be examined in the worst case? ITCS 2214:Data Structures 15 Mathematical Fundamentals

16 Space Complexity Space bounds can also be analyzed with asymptotic complexity analysis Time Complexity is generally relevant for algorithms Space Complexity is generally relevant for data structures. Space/Time Tradeoff: Reduction in computation time by sacrificing space, or vice versa. Encoding or packing information, eg., Boolean flags Table lookup, eg., Factorials, trig functions Disk Based Space/Time Tradeoff: Smaller disk storage requirements, the faster the algorithm. ITCS 2214:Data Structures 16 Mathematical Fundamentals

How do we compare algorithms meaningfully? (i.e.) the same algorithm will 1) run at different speeds 2) require different amounts of space

How do we compare algorithms meaningfully? (i.e.) the same algorithm will 1) run at different speeds 2) require different amounts of space when run on different computers! for (i = n-1; i > 0; i--) { maxposition