1 / 13

CSE 1342 Programming Concepts

CSE 1342 Programming Concepts. Algorithmic Analysis Using Big-O Part 2. Computing the Run Time of Loop Statements Without Function Calls. Computing the Run Time of an if-Statement Without Function Calls. Computing the Run Time of a Block Without Function Calls.

Download Presentation

CSE 1342 Programming Concepts

An Image/Link below is provided (as is) to download presentation 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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. CSE 1342 Programming Concepts Algorithmic Analysis Using Big-O Part 2

  2. Computing the Run Time of Loop Statements Without Function Calls

  3. Computing the Run Time of an if-Statement Without Function Calls

  4. Computing the Run Time of a Block Without Function Calls

  5. Program Illustrating Non-Recursive Function Calls

  6. Analyzing Programs with Non-Recursive Function Calls • Evaluate the running times for functions that do not call other functions. • bar - O(n) + O(1) = O(n) • Evaluate the running times of functions that only call functions already evaluated. • foo - O(n * n) + O(1) = O(n2) + O(1) = O(n2) • Proceed in this fashion until all functions have been evaluated. • main = O(n2 ) + O(n) + O(1) = O(n2)

  7. Selection Sort

  8. Selection Sort Analysis • The selection sort involves a nested loop that is driven be the control variable i in the outer loop. Each time a pass is made through the outer loop, the number of times through the is 1 less than the previous time. • Outer loop passes = f(n - 1) • Inner loop passes = f((n-1)+(n-2)+(n-3)+ … +1 • To sum the inner loop (the values from 1 to n), use the formula n(n-1)/2, where n = n-1 • (n-1)((n-1)-1)/2 = ((n-1)2-n-1)/2 = (n2-3n)/2 =O(n2)

  9. Recursive Binary Search int recSearch(int a[], int lb, int ub, int value) { //Recursive binary search routine int half; if(lb > ub) return -1; //value is not in the array half = (lb+ub) / 2; if(a[half] == value) //value is in the array return half; //return value's location else if(a[half] > value) return recSearch(a, lb, half-1, value); //search lower half of array else return recSearch(a, half+1, ub, value); //search upper half of array }

  10. Recursive Binary Search Analysis INITIAL CALL FOR a[0 TO 99] 2nd CALL FOR a[0 TO 48] int a[100], value = 20; //assume array has been initialized recSearch(a, 0, 99, value); //initial call from main( ) or 2nd CALL FOR a[50 TO 99] 3rd CALL FOR a[0 TO 23] 3rd CALL FOR a[25 TO 48] 3rd CALL FOR a[50 TO 73] 3rd CALL FOR a[75 TO 99] or or Binary Search is O(log2 n) or O(log n) Notice, there is only 1 call made at each level

  11. Towers of Hanoi void towers(int disks, int start, int end, int temp) { if (disks == 1) { cout << start << “ TO ” << end << endl; return; } // move disks – 1 disks from start to temp towers (disks – 1, start, temp, end); (1) // move last disk from start to end cout << start << “” << end << endl; // move disks – 1 disks from temp to end towers (disks – 1, temp, end, start); (2) }

  12. Towers of Hanoi Analysis INITIAL CALL n = 3; return to main 2nd CALL n = 2; return to 1 towers(3, 1, 3, 2); //initial call from main( ) and 5th CALL n = 2; return to 2 3rd CALL n = 1; return to 1 4th CALL n = 1; return to 2 6th CALL n = 1; return to 1 7th CALL n = 1; return to 2 and and Towers is O(en) Notice, every call at each level is made

  13. Towers of Hanoi Analysis • In terms of speed efficiency the Towers algorithm is O(2n) - exponential. • To illustrate, by adding another disk to the original call the number of recursive calls doubles. Add another disk and the number of calls doubles again. • In terms of memory usage the Towers algorithm is O(n) because the system stack will be at most n elements high.

More Related