CSCE 2100: Computing Foundations 1 Analyzing Iterative Programs

1. CSCE 2100: Computing Foundations 1Analyzing Iterative Programs Tamara Schneider Summer 2013

2. Running Time of Simple Statements Primitive operations in O(1) • Arithmetic operations (+, %, *, -, ...) • Logical operations (&&, ||, ...) • Accessing operations (A[i], x->y, ...) • Simple assignment • Calls to library functions (scanf, printf, ... )

3. Simple For-Loops [1] • Constant time for assignment • Neglect checking for loop condition etc (constant time) • Loop is executed times executed times ⇒ for(inti=0; i<n; i++) A[i]=0;

4. Simple For-Loops [2] for(inti=0; i<n; i++) for(intj=0; j<n; j++) A[i][j]=0; • Neglect checking for loop condition etc. (constant time) • Inner loop: • The inner loop is executed n times executed times ⇒ O(n2)

5. Analyzing if statements if(<condition>) <then part> else <else part> • Evaluation of condition takes a constant number of primitive operations ⇒ • Assume if-part has upper bound • Assume else-part has upper bound ⇒ • Whether or is larger may depend on the input size

6. If-else example if(A[1][1] == 0) for(inti=0; i<n; i++) for(intj=0; j<n; j++) A[i][j]=0; else for(inti=0; i<n; i++) A[i][i] = 0; • If-part: 2 nested loops executed times each; loop body is O(n) O(n2)total. • Else-part: 1 loop executed times; loop body is  O(n) total • Safe upper bound: O(n2)

7. Inner Loop of Selection Sort • The loop body takes time O(1) • The loop is executed times • The loop starts at • The loop’s condition becomes false for • The loop increment is 1 • ⇒ O(n-i-1) for(intj=i+1; j<n; j++) if(A[j] < A[small]) small = j;

8. Selection Sort [1] for(inti=0; i<n-1; i++){ small = i; for(int j=i+1; j<n; j++) if(A[j] < A[small]) small = j; int temp = A[small]; A[small] = A[i]; A[i] = temp; } //for How often is this block executed?

9. Selection Sort [2]

10. Complex Loops • Some loops do not specify explicitly how many times the loop body is executed • while, do-while, some for-loops • Analyze loop to find upper bound on number of iterations • May need to prove statement by induction

11. Complex Loop Example n = A.size() i= 0; while(x != A[i] && i < n) i++; • The loop is at most executed times • The upper bound on the loop is

12. Programs with Function Calls • If function call is non-recursive • Analyze function separately • Add cost of function to block • Function calls are a condition of while- or do-while loop • Add cost of function to block

13. Example [1] main(){ inta, n; scanf("%d", &n); a = foo(0,n); printf("%d", bar(a,n)); } int bar(int x, int n){ for(inti=1; i<=n; i++) x += i; returnx; } intfoo(int x, intn){ for(inti=1; i<=n; i++) x += bar(i,n); return x; }

14. foo main bar Example [2] main(){ inta, n; scanf("%d", &n); a = foo(0,n); printf("%d", bar(a,n)); } int bar(int x, int n){ for(inti=1; i<=n; i++) x += i; returnx; } 1. Check for recursion(direct or indirect) intfoo(int x, intn){ for(inti=1; i<=n; i++) x += bar(i,n); return x; }

15. foo main bar Example [3] main(){ inta, n; scanf("%d", &n); a = foo(0,n); printf("%d", bar(a,n)); } int bar(int x, int n){ for(inti=1; i<=n; i++) x += i; returnx; } intfoo(int x, intn){ for(inti=1; i<=n; i++) x += bar(i,n); return x; } 2. Running time of bar O(n)

16. foo main bar Example [4] main(){ inta, n; scanf("%d", &n); a = foo(0,n); printf("%d", bar(a,n)); } int bar(int x, int n){ for(inti=1; i<=n; i++) x += i; returnx; } intfoo(int x, intn){ for(inti=1; i<=n; i++) x += bar(i,n); return x; } 3. Running time of foo O(n2) O(n)

17. foo main bar Example [5] main(){ inta, n; scanf("%d", &n); a = foo(0,n); printf("%d", bar(a,n)); } int bar(int x, int n){ for(inti=1; i<=n; i++) x += i; returnx; } intfoo(int x, intn){ for(inti=1; i<=n; i++) x += bar(i,n); return x; } 4. Running time of main O(n2) O(n2) O(n)

18. Summary • Primitive operations are considered to have a constant running time. • Analyzing simple loops makes use of the number of iterations and the cost of the loop body. • To analyze complex loops the “worst case” may need to be assumed. • Analyzing conditional statement involves using the “worst case”. • Non-recursive functions can be analyzed independently.