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
int a[100], value = 20; //assume array has been initialized
recSearch(a, 0, 99, value); //initial call from main( )
INITIAL CALL FOR
a[0 TO 99]
2nd CALL FOR
a[0 TO 48] 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 if (disks == 1) {
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
towers(3, 1, 3, 2); //initial call from main( )
INITIAL CALL
n = 3; return to main
2nd CALL
n = 2; return to 1
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.