✎ aa:lab:07 [books]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Lab 07 - Recurrences ======


==== 1. Basic algorithms ====

**1.1** Based on the following code for Bubble-sort, analyze the algorithm's time complexity:
    void bubbleSort(int arr[], int n)
    {
        int i, j, temp;
        for(i = 0; i < n; i++)
        {
            for(j = 0; j < n-i-1; j++)
            {
                if( arr[j] > arr[j+1])
                {
                    // swap the elements
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                } 
            }
        }
    }

**1.2** Based on the following code for Insertion sort, analyze the algorithm's time complexity:
    void insertionSort(int arr[], int n)  
    {  
        int i, key, j;  
        for (i = 1; i < n; i++) 
        {  
            key = arr[i];  
            j = i - 1;  
      
            /* Move elements of arr[0..i-1], that are  
            greater than key, to one position ahead  
            of their current position */
            while (j >= 0 && arr[j] > key) 
            {  
                arr[j + 1] = arr[j];  
                j = j - 1;  
            }  
            arr[j + 1] = key;  
        }  
    }


==== 2. Simple Recurrences  ====

Consider the following search algorithm of a value v in a sorted array arr:  
    int search (int arr[], int lo, int hi, int v){
        int mid = (lo+hi)/2;  
        if (arr[mid] == v)
            return mid;
        if (lo == hi)
            return -1;
        if (arr[mid] > v)
            return search(arr, lo, mid, v);
        else
            return search(arr, mid, hi, v);
    }
    
**2.1** Determine the recurrence for the search algorithm above.

**2.2** Solve the recurrence using the Master Method.

**2.3** Solve the recurrence using the Trees Method.

**2.4** Solve the recurrence using the Substitution Method.

==== 3. More recurrences ====

Consider the following modification to 'search' (which may not make sense in practice):
    
    int search (int arr[], int lo, int hi, int v){
        if (!is_sorted(arr, lo, hi))
            return -1;
        //rest just the same
    }
    
**3.1** In what time can we check if an array is sorted?

**3.2** What is the new recurrence for search?

**3.3** Solve the recurrence, using all three methods.

==== 4. Atypical situations when solving recurrences ====

**4.1** Substitution method does not work. Solve T(n) = 2T(n/2)+1.

**4.2** Un-balanced trees. Solve T(n) = T(n/4) + T(3n/4) + n via the tree and substitution methods.

**4.3** Solve T(n) = 2T(n/2) + n^2.

**4.4** Look up the Hanoi towers problem. Determine the number of steps necessary to solve it.

**4.5** Consider the following algorithm:
     
     int fibo(int n){
        if (n <= 1)
            return n;
        return fibo(n-1) + fibo(n-2);
     }
     
 Determine its complexity with regard to the *size* of the input.

**4.6** Solve T(n) = sqrt(n) * T(sqrt(n)) + n.