Question

3a. Runtime Analysis: For each of the following recursive algorithms, state the recurrence equation that is the runtime of the algorithm. Briefly describe how you determined each term. You do not need to provide the runtime bound – just the equation. T(n) = Product(array, p) // n is size of array if (p>n) return 1 if (array[p] != 0) return array[p] * Product(array, p+1) else return Product(array, p+1) Describe terms: T(n) = Describe terms: // modified merge sort mod Merge( A, p, r) if (p<r) div = floor(r-p)/4) q1 = p+div q2 = p+div*2 q3 = p+div*3 modMerge(A, p, q1) modMerge(A, q1+1, 92) modMerge(A, 92+1,93) modMerge(A, q3+1, r) Merge(A,p,1,91,92,93)

Answer 1

Here is the solution to above problem. Please read the explanation for more information

GIVE A THUMBS UP!!!

1)

Product(array,P)
{
   //base case takes only O(1) time
   if(p>n)
   {
       return 1; //O(1)
   }
   if(array[p]!=0) //O(1)
       //recursive call to Product(N-1)
       return array[p] *Product(array,p+1);
   else
   //recursive call to Product(N-1)
       return Product(array,p+1);   
}

Explanation

In the above problem base condition and if condition are present other than that a recursive call to Product(P+1) is done if the Size of Array is N than the recurrence relation is

T(N) = T(N-1) + C where C is constant which represents all the constant time statement in program and C has time complexity O(1)

2)

modMerge(A,p,r)
{
   if(p<r)
   {
       //we divide the merge sort into 4 parts
       div=floor(r-p)/4;
       //4 intervals each of equal size
       q1=p+div;
       q2=p+div*2;
       q3=p+div*3;
       //We divide this modified MergeSort into 4 equal parts unlike th
       //traditional merge sort with 2 equal parts
       modMerge(A,p,q1);
       modMerge(A,q1+1,q2);
       modMerge(A,q2+1,q3);
       modMerge(A,q3+1,r);
       //here we call the merge function which will Take maximum
       //O(N) time were N is the size of the array
       Merge(A,p,r,q1,q2,q3);
      
   }
}

Explanation

In this modified version of the merge sort unlike the normal one , We divide the merge sort into 4 equal parts , Hence we get 4 recurrence relation and Still the Merge function only takes N time since all part combined together have max size O(N) where N is the size of array

T(N) = 4T(N/4) + N