Divide and Conquer Algorithms

Transcription

1 Divide and Conquer Algorithms Divide a problem into several smaller instances of the same problem, ideally with instances of about the same size. Solve the smaller instances, normally using recursion. For some problems, combine the solution to the smaller instances to solve the original problem.

2 Merge Sort Sort an array with n elements by dividing it into two halves with index ranges [0,n/2) and [n/2, n-1], n sorting each half recursively, and then merging the two smaller sorted arrays into a single sorted array. The merging process involves using a temporary array with n elements.

3 Merge Algorithm Start with array arr having n elements and create an array, temparr,, with n elements. Let mid = (first + last)/2, and assume that ranges [first, mid) and [mid, last) are sorted. Let integers indexa = first and indexb = mid.

4 Merge Algorithm (continued) Move indexa through [first, mid), and indexb through [mid, last), copying the smallest of arr[indexa] ] and arr[indexb] ] to position indexc in temparr. Stop when indexa = mid or indexb = last. Elements will remain in one sublist.. Copy the tail of the sublist to tmparr.

5 Merge Illustration Step 1

6 Merge Illustration Step 2

7 Merge Illustration Step 3

8 Merge Illustration Steps 4-74

9 Merge Illustration Steps 8-98

10 Merge Illustration Conclusion The merge algorithm concludes by copying the elements from temparr back to the original array, starting at index first.

11 General Sort Methods The Arrays class provides two versions of the method sort(), which implements the megesort algorithm. One version has an Object array arr as its parameter. The other version is generic and specifies arr as an array of type T. Both methods call the private method msort() that carries out the mergesort algorithm.

12 sort() - with Object array public static void sort(object[] arr) { // create a temporary array to store // partitioned elements Object[] temparr = arr.clone(); } // call msort with arrays arr and temparr along // with the index range msort(arr, temparr, 0, arr.length);

13 sort() - Generic version public static <T extends Comparable<? super T>> void sort(t[] arr) { // create a temporary array to store // partitioned elements T[] temparr = (T[])arr.clone(); } // call msort with arrays arr and temparr along // with the index range msort(arr, temparr, 0, arr.length);

14 The msort() Method Create two half-lists lists by computing the index midpt,, representing the midpoint of the index range: int midpt = (last + first)/2; Call msort for the index range [first, mid) and for the index range [mid, last). When returning from the recursive calls, apply the merge algorithm to the range [first, last).

15 Tracing the msort() Algorithm

16 msort() Notes A singleton sublist is already sorted. Such a list has index range [first, first+1), where last = first The recursive process continues only as long as first+1 < last. Do not merge if arr[mid-1] < arr[mid].

17 msort() private static void msort(object[] arr, Object[] temparr, int first, int last) { // if the sublist has more // than 1 element continue if (first + 1 < last) { // for sublists of size 2 or more, call msort() // for the left and right sublists and then // merge the sorted sublists using merge() int midpt = (last + first) / 2; msort(arr, temparr, first, midpt); msort(arr, temparr, midpt, last);

18 msort() (continued) // if list is already sorted, just copy from // src to dest; this is an optimization that // results in faster sorts for nearly // ordered lists if (((Comparable)arr[midpt-1]).compareTo (arr[midpt]) <= 0) return; // the elements in the ranges (first,mid) // and (mid,last) are ordered; merge the // ordered sublists into an ordered sequence // in the range (first,last) using // the temporary array int indexa, indexb, indexc;

19 msort() (continued) // set indexa to scan sublist A // with range (first, mid) // and indexb to scan sublist B // with range (mid, last) indexa = first; indexb = midpt; indexc = first; // while both sublists are not exhausted, // compare arr[indexa] and arr[indexb]; // copy the smaller to temparr while (indexa < midpt && indexb < last){ if (((Comparable)arr[indexA]).compareTo (arr[indexb]) < 0) { // copy to temparr temparr[indexc] = arr[indexa]; // increment indexa indexa++; }

20 msort() (continued) } else { // copy to temparr temparr[indexc] = arr[indexb]; // increment indexb indexb++; } // increment indexc indexc++; // copy the tail of the sublist // that is not exhausted while (indexa < midpt) { // copy to temparr temparr[indexc] = arr[indexa]; indexa++; indexc++; }

21 msort() (concluded) } } while (indexb < last) { // copy to temparr temparr[indexc] = arr[indexb]; indexb++; indexc++; } // copy elements from temporary // array to original array for (int i = first; i < last; i++) arr[i] = temparr[i];

22 Student Question There appears to be two while loops at the bottom of the code: one copies from the left subarray into the temp array and the other copies from the right subarray into the temp array Why do we need both loops since both subarrays cannot be nonempty when exiting the main merging loop

23 Recursion Tree for Merge Sort

24 Efficiency of Merge Sort Add up the number of comparisons done at each level of the recursion tree of height (int)log 2 n. At each level i in the tree, a merge involves n/2 i elements and requires less than n/2 i comparisons. The combined 2 i merges at level i require less than 2 i * (n/2 i ) = n comparisons. The worst case running time is O(n log 2 n).

25 Student Question The previous sorts we have seen do not require extra array space to store temporary results Is there any way to merge sort to avoid using this temporary space?