Divide and Conquer Approach

Divide and Conquer Approach Divide the problems into a number of sub problems. Conquer the sub problems by solving them recursively. If the sub-problem sizes are small enough, just solve the problems in a straight forward manner. Combine the solutions to the sub problems into the solution for the original problem.

Merge Sort Divide the n element sequence to be sorted into two subsequences of n/2 elements each. Conquer: Sort the two subsequences to produce the sorted answer. Combine: Merge the two sorted sub sequences to produce the sorted answer.

Merge Sort Base Case: When the sequences to be sorted has length 1. 14 34 89 56 66 108 12 Sorted 108 56 12 14 89 34 66 Unsorted 108 56 14 66 Divide 56 66 108 14 Merge 34 12 89 Merge 12 89 34 Divide 108 66 Divide 14 56 Merge 56 14 Divide 12 89 Divide 89 12 Merge 34 Merge 34 Divide 34 BCase 66 108 Merge 89 Divide 89 BCase 89 Merge 12 BCase 12 Merge 12 Divide 66 BCase 66 Divide 66 Merge 108 Merge 108 Divide 108 BCase 56 Merge 56 Divide 56 BCase 14 BCase 14 Divide 14 Merge

Merge Sort Algorithm MergeSort(A, i, j) if j > i then mid ← (i + j)/2 MergeSort(A, i, mid ) MergeSort(A, mid + 1, j ) Merge(A, i, mid, j )

Merge Algorithm //LeftPos = start of left half; //RightPos = start of right half void Merge(int A[ ], int LeftPos, int RightPos, int RightEnd) { int LeftEnd = RightPos – 1; int TmpPos = 1 int NumElements = RightEnd – LeftPos + 1; int TempArray[NumElements]; while(leftPos <= LeftEnd && RightPos <= RightEnd) if(A[LeftPos] <= A[RightPos]) TmpArray[TmpPos++] = A[LeftPos++]; else TmpArray[TmpPos++] = A[RightPos++]; while(LeftPos <= LeftEnd) //Copy rest of first half while(RightPos <= RightEnd) //Copy rest of second half TmpArray[TmpPos++] = A[RightPos++]; for(int i = 1; i <= NumElements; i++) //Copy TmpArray back A[LeftPos++] = TmpArray[i]; }

Merge Algorithm The basic merging algorithms takes Two input arrays, A[] and B[], An output array C[] And three counters aptr, bptr and cptr. (initially set to the beginning of their respective arrays) The smaller of A[aptr] and B[bptr] is copied to the next entry in C i.e. C[cptr]. The appropriate counters are then advanced. When either of input list is exhausted, the remainder of the other list is copied to C.

Merge Algorithm 34 12 89 B[] bptr 56 66 108 14 A[] aptr 14 > 12 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 12 12 C[] cptr

Merge Algorithm 34 12 89 B[] 56 66 108 14 A[] aptr bptr 14 > 12 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 12 12 cptr++ cptr C[]

Merge Algorithm 34 12 89 B[] 56 66 108 14 A[] aptr bptr bptr++ 14 > 12 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 12 12 cptr++ C[] cptr

Merge Algorithm 56 66 108 14 A[] aptr 34 12 89 B[] bptr 14 < 34 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 14 14 C[] 12 cptr

Merge Algorithm 34 12 89 B[] 56 66 108 14 A[] aptr bptr 14 < 34 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 14 14 cptr++ C[] 12 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] aptr aptr++ bptr 14 < 34 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 14 14 cptr++ C[] 12 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] bptr aptr 56 > 34 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 34 34 C[] 12 14 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] bptr aptr 56 > 34 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 34 14 cptr++ C[] 12 34 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] bptr bptr++ aptr 56 > 34 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 34 14 cptr++ C[] 12 34 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] bptr aptr 56 < 89 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 56 56 C[] 12 14 34 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] bptr aptr 56 < 89 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 56 56 cptr++ cptr C[] 12 14 34

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] aptr aptr++ bptr 56 < 89 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 56 56 cptr++ C[] 12 14 34 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] aptr bptr 66 < 89 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 66 66 C[] 12 14 34 56 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] aptr bptr 66 < 89 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 66 cptr++ C[] 12 14 34 56 66 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] aptr aptr++ bptr 66 < 89 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 66 cptr++ C[] 12 14 34 56 66 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] aptr bptr 108 > 89 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 89 89 C[] 12 14 34 56 66 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] aptr bptr 108 > 89 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 89 89 cptr++ C[] 12 14 34 56 66 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] bptr aptr bptr++ 108 > 89 therefore If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[cptr] = 89 89 cptr++ C[] 12 14 34 56 66 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] aptr bptr Array B is now finished, copy remaining elements of array A in array C If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[] 12 14 34 56 66 89 cptr

Merge Algorithm 56 66 108 14 A[] 34 12 89 B[] aptr bptr Array B is now finished, copy remaining elements of array A in array C If A[aptr] < B[bptr] C[cptr++] = A[aptr++] Else C[cptr++] = B[bptr++] C[] 12 14 34 56 66 89 108 cptr

Merge Algorithm Analysis Suppose total number of elements to be merged is n Running time is O(n)

Merge Sort Analysis MergeSort computation tree has depth log n Associate some running time with each node in computation tree Sum up times at each node to find total running time

Computation Tree N = 7 lg 7  = 3 Tree Depth = 3 108 56 12 14 89 34 66 108 56 14 66 12 89 34 108 66 56 14 12 89 34 66 108 56 14 89 12

Computation of Time What is included in running time of a node: Time Spent at a node What is included in running time of a node: time to divide up input: O(1) time to make recursive calls: O(1) time to merge results of recursive calls: O(n) Total Time : O(n)

Merge Sort Analysis Consider one level at a time every element appears once on each level (except perhaps lowest level) n elements on each level O(n) running time per level O(log n) levels Total running time: O(n log n)

Problem with Merge Sort Merging two sorted lists requires linear extra memory. Additional work spent copying to the temporary array and back through out the algorithm. This problem slows down the sort considerably.