1. CSE 326 Analyzing Recursion David Kaplan Dept of Computer Science & Engineering Autumn 2001

2. Analyzing RecursionCSE 326 Autumn 20012 Recursion Rules Rules for using recursion effectively (Weiss 1.3): 1. Base cases Must have some non-recursive base case(s). 2. Making progress Recursive call must progress toward a base case. 3. Design rule Assume the recursive calls work. 4. Compund interest rule Don’t duplicate work in separate recursive calls.

3. Analyzing RecursionCSE 326 Autumn 20013 Recurrence Equations  A recursive procedure can often be analyzed by solving a recurrence equation of the form: T(n) = base case: some constant recursive case: T(subproblems) + T(combine)  Result depends upon  how many subproblems  how much smaller are subproblems  how costly to combine solutions (coefficients)

4. Analyzing RecursionCSE 326 Autumn 20014 Example: Sum of Queue SumQueue(Q) if (Q.length == 0 ) return 0 else return Q.dequeue() + SumQueue(Q) One subproblem Linear reduction in size (decrease by 1) Combining: constant (cost of 1 add) T(0)  b T(n)  c + T(n – 1) for n>0

5. Analyzing RecursionCSE 326 Autumn 20015 Sum of Queue Solution T(n)  c + c + T(n-2)  c + c + c + T(n-3)  kc + T(n-k) for all k  nc + T(0) for k=n  cn + b = O(n) T(0)  b T(n)  c + T(n – 1) for n>0 Equation: Solution:

6. Analyzing RecursionCSE 326 Autumn 20016 Example: Binary Search BinarySearch(A, x) if (A.size == 1) return (x == A[0]) mid = A.size / 2 if (x == A[mid]) return true else if (x < A[mid]) return BinarySearch( A_LowerHalf, x) else if (x > A[mid]) return BinarySearch( A_UpperHalf, x) T(1)  b T(n)  T(n/2) + c for n>1 Equation: Search a sorted array for a given item, x  If x == middle array element, return true  Else, BinarySearch lower (x mid) sub-array  1 subproblem, half as large

7. Analyzing RecursionCSE 326 Autumn 20017 Binary Search: Solution T(n)  T(n/2) + c  T(n/4) + c + c  T(n/8) + c + c + c  T(n/2 k ) + kc  T(1) + c log n where k = log n  b + c log n = O(log n) T(1)  b T(n)  T(n/2) + c for n>1 Equation: Solution:

8. Analyzing RecursionCSE 326 Autumn 20018 Recursion Tree for Binary Search n n/2 n/4 … 1 O(1) … log n Θ(log n) O(1) Problem sizeCost per stage

9. Analyzing RecursionCSE 326 Autumn 20019 Example: MergeSort Split array in half, sort each half, merge sub-arrays  2 subproblems, each half as large  linear amount of work to combine T(n)  2T(n/2)+cn  2(2(T(n/4)+cn/2)+cn = 4T(n/4) +cn +cn  4(2(T(n/8)+c(n/4))+cn+cn = 8T(n/8)+cn+cn+cn  2kT(n/2k)+kcn  2kT(1) + cn log n where k = log n = O(n log n)

10. Analyzing RecursionCSE 326 Autumn 200110 Recursion Tree for Merge Sort n n/2 n/4 ……… 111 O(n) … log n Θ(n log n) Problem sizeCost per stage

11. Analyzing RecursionCSE 326 Autumn 200111 Example: Recursive Fibonacci Fibonacci numbers seems like a great use of recursion  Simple, elegant-looking recursive code … Fibonacci(i) if (i == 0 or i == 1) return 1 else return Fibonacci(i - 1) + Fibonacci(i - 2)

12. Analyzing RecursionCSE 326 Autumn 200112 Fibonacci Call Tree Fib(5) Fib(4) Fib(3) Fib(2) Fib(3) Fib(1) Fib(0) Fib(1) Fib(2) But what actually happens is combinatorial explosion

13. Analyzing RecursionCSE 326 Autumn 200113 Analyzing Recursive Fibonacci  Running time: Lower bound analysis T(0), T(1)  1 T(n)  T(n - 1) + T(n - 2) + c if n > 1  Note: T(n)  Fib(n)  Weiss shows in 1.2.5 that Fib(n) < (5/3) n  Similar logic shows that Fib(n)  (3/2) n for N>4  In fact: Fib(n) =  ((3/2) n ), Fib(n) = O((5/3) n ), Fib(n) = θ(  n ) where  = (1 +  5)/2

14. Analyzing RecursionCSE 326 Autumn 200114 Non-Recursive Fibonacci Avoid recursive calls  Keep a table of calculated values  each time you calculate an answer, store it in the table  Before performing any calculation for a value n  check if a valid answer for n is in the table  if so, return it Memoization  a form of dynamic programming How much time does memoized Fibonacci take?