recursion and recurrence equations

Recursion and Recurrence Equations

• The execution of a recursive program• Deriving recurrence equations

04/22/23 Cutler/Head 2

Recursion

• What is the recursive definition of n! ?

• Translating to Java/cint fact(int n) {

if (n<=1) return 1; // Note '*' is done after returning from fact(n-1)

else return n*fact(n-1);}

otherwise )1)!-((1or 0 is if 1

!nn

nn


Recursive algorithms

• A recursive algorithm typically contains recursive calls to the same algorithm

• In order for the recursive algorithm to terminate, it must contain code for solving directly some “base case(s)”

• A direct solution does not include recursive calls. • We use the following notation:• DirectSolutionSize is the “size” of the base case• DirectSolutionCount is the count of the number of

operations done by the “direct solution”


fact(3)

3

2

1

fact(2)

fact(1)

A Call Tree for fact(3) The Run Time Environment

• The following 2 slides show the program stack after the third call from fact(3)

• When a function is called an activation records('ar') is created and pushed on the program stack.

• The activation record stores copies of local variables, pointers to other ‘ar’ in the stack and the return address.

• When a function returns the stack is popped.int fact(int n) {

if (n<=1) return 1;else return n*fact(n-1);}

returns 6

1

*

*2

6


ep2

Program stack

Valfact: <ipF,ep0>

N =3function value [=?]

return addressstatic link = ep0

dynamic link =ep1

free memory

AR(Driver)

AR(fact 3)

Snapshot of the environmentat end of third call to fact

ep0



dynamic link =ep2

AR(fact 2)

ep1

EP

N =1function value [=1]


dynamic link = EP

AR(fact 1)

AR=Activation Recordep= environmental pointer

EP

Program stack

Valfact: <ipF,ep0>



dynamic link = ep1

free memory

AR(Driver)

AR(fact 3)

Snapshot of the environmentat end of second call to fact

ep0

N =2function value [=2]


dynamic link = EP

AR(fact 2)

ep1


EP

Program stack

Val

fact: <ipF,ep0>

N =3

function value [=6]

return address

static link = ep0

dynamic link = EP

free memory

AR(Driver)

AR(fact 3)

Snapshot of the environment

at end of first call to fact

ep0EP

Program stack

Val

fact: <ipF,ep0>

free memory

AR(Driver)

Snapshot of the environment

after fact l returns


Goal: Analyzing recursive algorithms

• Until now we have only analyzed (derived a count) for non-recursive algorithms.

• In order to analyze recursive algorithms we must learn to:

• Derive the recurrence equation from the code• Solve recurrence equations.


Deriving a Recurrence Equation fora Recursive Algorithm

• Our goal is to compute the count (Time) T(n) as a function of n, where n is the size of the problem

• We will first write a recurrence equation for T(n)For example T(n)=T(n-1)+1 and T(1)=0

• Then we will solve the recurrence equationWhen we solve the recurrence equation above we will

find that T(n)=n, and any such recursive algorithm is linear in n.

Solving: Next lecture


Deriving a Recurrence Equation for a Recursive Algorithm

1. Determine the “size of the problem”. The count T is a function of this size

2. Determine DirectSolSize, such that for size DirectSolSize the algorithm computes a direct solution, and the DirectSolCount(s).

otherwise

)(

ntGeneralCouizeDirectSolSsizeountDirectSolC

sizeT


Deriving a Recurrence Equation for a Recursive Algorithm

To determine GeneralCount:

3. Identify all the recursive calls done by a single call of the algorithm and their counts, T(n1),…,T(nk) and

compute RecursiveCallSum =

4. Determine the “non recursive count” t(size) done by a single call of the algorithm, i.e., the amount of work, excluding the recursive calls done by the algorithm

otherwise )(Re

)(

sizetlSumcursiveCalizeDirectSolSsizeountDirectSolC

sizeT

)(1

k

iinT


Deriving DirectSolutionCount for Factorial

int fact(int n) {if (n<=1) return 1;

// Note '*' is done after returning from fact(n-1)else

return n*fact(n-1);1. Size = n 2.DirectSolSize is (n<=1)3. DirectSolCount is (1)

The algorithm does a small constant number of operations (comparing n to 1, and returning)


Deriving a GeneralCount for Factorial

int fact(int n) {if (n<=1) return 1;

// Note '*' is done after returning from fact(n-1)else

return n * fact(n-1);

3. RecursiveCallSum = T( n - 1)

4. t(n) = (1) (for if, *, -, return)

The only recursive call, requiring T(n - 1) operations

1for )1()1(

1for )1()(

nnTn

nT

Operationscounted in t(n)


Deriving a Recurrence Equation for Mystery

In this example we are not concerned with what mystery computes. Our goal is to simply write the recurrence equation

mystery (n)1. if n 12. then return n3. else return (5 * mystery(n -1) -

6* mystery(n -2) )


Deriving a DirectSolutionCount for Mystery1. Size = n

2. DirectSolSize is (n<=1)3. DirectSolCount is (1)

The algorithm does a small constant number of operations (comparing n to 1, and returning)

1for

1for )1()(

nntGeneralCoun

nT


Deriving a GeneralCount for Mystery

mystery (n)1. if n 12. then return n3. else

return (5 * mystery(n -1) -

6 * mystery(n - 2) )

A recursive call toMystery requiring T(n - 1)

A recursive call toMystery requiring T(n - 2)

Operations counted in t(n)


Deriving a Recurrence Equation for Mystery

3. RecursiveCallSum = T(n-1) + T(n-2)4. t (n)= (1)

The non recursive count includes the comparison n<=1, the 2 multiplications, the subtraction, and the return. So (1).

1for )1()2()1(

1for )1()(

nnTnTn

nT


Deriving a Recurrence Equation for MultiplyMultiply(y, z)//binary multiplication1. if (z ==0) return 02.else if z is odd3.then return (multiply(2y,z/2) + y)4.else return (multiply(2y,z/2))

To derive the recurrence equation we need to determine the size of the problem. The variable which is decreased and provides the direct solution is z. So we can use z as the size. Another possibility is to use n which is the number of bits in z (n=lg z+1).

Let addition be our barometer operation. We do 0 additions for the direct solution. So DirectSolutionSize =0, and DirectSolutionCount=0

Barometeroperation


Deriving a Recurrence Equation for Multiply

1. RecursiveCallSum = T(z/2)t(z) = 1 addition in the worst case. So

Solving this equation we get T(z)= (lg z)= (n).

2. RecursiveCallSum = T(n-1) since z/2 has n-1 bits

Solving this equation we get T(n)= (n)

0for 1)1(

0for 0)(

nnTn

nT

0for 1)2/(

0for 0)(

zzTz

zT


Deriving a recurrence equation for minimumMinimum(A,lt,rt) // minimum(A,1,length(A))1. if rt - lt 12.then return (min(A[lt], A[rt]))3.else m1 = minimum(A,lt, (lt+rt)/2)4. m2 = minimum(A,(lt+rt)/2+1,rt)5. return (min (m1, m2))• This procedure computes the minimum of the left

half of the array, the right half of the array, and the minimum of the two.

• Size = rt-lt+1= n • DirectSolutionSize is n = (rt - lt)+1 1+1=2.• DirectSolutionCount = (1)


Deriving a recurrence equation for minimumMinimum(A,lt,rt) // minimum(A,1,length(A))1. if rt - lt 12.then return (min(A[lt], A[rt]))

3.else m1 = minimum(A,lt, (lt+rt)/2)

4. m2 = minimum(A,(lt+rt)/2+1,rt)5. return (min (m1, m2))

Two recursive calls with n/2 elements.So T(n/2) + T(n/2)

2for )1()2/(2

2for )1()(

nnTn

nT


Deriving a recurrence equation for Merge Sort:

1 if (n 2) 2 moveFirst( S, S1, (n+1)/2)) // divide3 moveSecond( S, S2, n/2) // divide4 Sort(S1) // recurs5 Sort(S2) // recurs6 Merge( S1, S2, S ) // conquers

DirectSolutionSize is n<2 DirectSolutionCount is (1) RecursiveCallSum is T( n/2) + T( n/2) The non recursive count t(n) = (n)


Recurrence Equation for cost.

• The implementation of the moves costs (n) and the merge costs (n). So the total cost for dividing and merging is (n).

• The recurrence relation for the run time of Sort is T(n) = T( n/2) + T( n/2) + (n) . T(0) =T(1) = (1)

• The solution is T(n)= (nlg n)


Computing xn

• We can decrease the number of times that x is multiplied by itself by observing that to compute x8 we need only 3 multiplications

(x2=x*x, x4=x2*x2, and x8=x4*x4) and when we want of compute x9, we need 4 multiplications

(x2=x*x, x4=x2*x2, x8=x4*x4 and x9= x8*x)• A recursive procedure for computing xn should be (lg

n)• For the following algorithm we will derive the worst

case recurrence equation. • Note: we are ignoring the fact that the numbers will

quickly become too large to store in a long integer


Recursion - Power

long power (long x, long n) { if (n == 0) {

return 1; } else { long p = power(x, n/2); if ((n % 2) == 0) {

return p*p; } else {

return x * p*p;} } }We use the * as our barometer operation.


Deriving a Recurrence Equation for PowerSize = nDirectSolutionSize is n=0; DirectSolutionCount is 0; RecursiveCallSum is T(n/2)t(n) = 2 multiplications in the worst case

T(n)=0 for n=0T(n)=T(n/2)+2 for n>0

//

recursion and recurrence equations

Documents