如何解决此乘法算法的递归关系

Question

How to I establish a big-O upper bound for the number of times the function calls itself, as a function of b for the following:

  function multiply(a,b)
     if b = 0 then return 0
     else if b is even then
       t := multiply(a, b/2);
       return t+t;
     else if b is odd then
       t := multiply(a, b-1);
       return a+t;

this is a function to multiply two integer numbers. I'm confused on how to handle the if else conditions for the recurrence relation. I was thinking that the answer is T(n) = T(n/2) + T(n-1). Is that correct?

Answer 1

 function multiply(a,b)
     if b = 0 then return 0
     else if b is even then
       t := multiply(a, b/2);
       return t+t;
     else if b is odd then
       t := multiply(a, b-1);
       return a+t;

Therefore:

F(0) = 0
If Even: F(N) = F(N/2) + 1 
If Odd-Even: F(N) = F(N-1) + 1 = F((N-1)/2) + 2 <-next number is definitely even

Solving the odd-even-odd-even case(the worst scenario):

F(N) = F((N-1)/2) + 2 = O(LogN)

Another way to think of the problems is that we know the odd-even-odd-even case has at most twice the depth of even-even-even-even case. The even only case has LogN depth, thus odd-even-odd-even case has at most 2*LogN depth.

Answer 2

Appreciate the following two points:

• Calling multiply with an odd input will trigger a call to the same input minus one, which is an even number. This will take one additional call to reach an even number.
• Calling multiply with an even input will trigger another call with the input halved. The resulting number will either be even, or odd, qv the above point.

In the worst case scenario, starting with an even input, it would take two calls to halve the input being passed to multiply . This behavior is consistent with 2*O(lgN) running time (where lg is the log base 2). This is the same as just O(lgN) .