Differences

This shows you the differences between two versions of the page.

--- aa:lab:07 [2020/11/12 12:27]
roxana_elena.stiuca chanded name
+++ aa:lab:07 [2020/11/23 23:12] (current)
claudiu.dorobantu
@@ Line 8: / Line 8: @@
     {
         int i, j, temp;
-        for(i = 0; i < n; i++)
+        for(i = 0; i < n - 1; i++)
         {
-            for(j = 0; j < n-i-1; j++)
+            for(j = 0; j < n - i - 1; j++)
             {
-                if( arr[j] > arr[j+1])
+                if(arr[j] > arr[j + 1])
                 {
                     // swap the elements
                     temp = arr[j];
-                    arr[j] = arr[j+1];
+                    arr[j] = arr[j + 1];
-                    arr[j+1] = temp;
+                    arr[j + 1] = temp;
                 }
             }
@@ Line 23: / Line 23: @@
     }
-**1.2** Based on the following code for Insertion sort, analyze the algorithm's time complexity:
+**1.2** Based on the following code for Selection sort, analyze the algorithm's time complexity:
-    void insertionSort(int arr[], int n)
+    void selectionSort(int arr[], int n)
     {
-        int i, key, j;
+        int i, j, min_idx, temp;
-        for (i = 1; i < n; i++)
+        for (i = 0; i < n - 1; i++)
         {
-            key = arr[i];
+            min_idx = i;
-            j = i - 1;
+            for (j = i + 1; j < n; j++)
+                if (arr[j] < arr[min_idx])
-            /* Move elements of arr[0..i-1], that are
+                    min_idx = j;
-            greater than key, to one position ahead
-            of their current position */
+            // swap the min element with the first element
-            while (j >= 0 && arr[j] > key)
+            temp = arr[min_idx];
-            {
+            arr[min_idx] = arr[i];
-                arr[j + 1] = arr[j];
+            arr[i] = temp;
-                j = j - 1;
-            }
-            arr[j + 1] = key;
         }
     }
@@ Line 48: / Line 45: @@
 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 search(int arr[], int lo, int hi, int v)
-        int mid = (lo+hi)/2;
+    {
+        int mid = (lo + hi) / 2;
         if (arr[mid] == v)
             return mid;
@@ Line 59: / Line 57: @@
             return search(arr, mid, hi, v);
     }
 **2.1** Determine the recurrence for the search algorithm above.
-**1.2** Solve the recurrence using the Master Method.
+**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;
+        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);
+    }
+**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 $math[T(n) = 2 T(] $math[n \over 2] $math[) + 1].
+**4.2** Un-balanced trees. Solve via the tree and substitution methods: $math[T(n) = T(] $math[n \over 4] $math[) + T(] $math[3n \over 4] $math[) + n].
+**4.3** Solve $math[T(n) = 2 T(] $math[n \over 2] $math[) + 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);
+     }
-**1.3** Solve the recurrence using the Trees Method.
+Determine its complexity with regard to the size of the input.
-**1.4** Solve the recurrence using the Substitution Method.
+**4.6** Solve $math[T(n) = \sqrt n * T(\sqrt n) + n].