Outline. 1 Merging. 2 Merge Sort. 3 Complexity of Sorting. 4 Merge Sort and Other Sorts 2 / 10

Transcription

1 Merge Sort 1 / 10

2 Outline 1 Merging 2 Merge Sort 3 Complexity of Sorting 4 Merge Sort and Other Sorts 2 / 10

3 Merging Merge sort is based on a simple operation known as merging: combining two ordered arrays to make one larger ordered array To sort an array, divide it into two halves, sort the two halves (recursively), and then merge the results Merge sort overview input sort left half sort right half merge results M E R G E S O R T E X A M P L E E E G M O R R S T E X A M P L E E E G M O R R S A E E L M P T X A E E E E G L M M O P R R S T X 3 / 10

4 Merging The merge algorithm package edu. princeton.cs. algs4 ; import java. util. Comparator ; public class Merge { private static void merge ( Comparable [] a, Comparable [] aux, int lo, int mid, int hi) { int i = lo, j = mid + 1; for ( int k = lo; k <= hi; k ++) { aux [k] = a[k]; for ( int k = lo; k <= hi; k ++) { if (i > mid ) { a[k] = aux [j ++]; else if (j > hi) { a[k] = aux [i ++]; else if ( less ( aux [j], aux [i ])) { a[k] = aux [j ++]; else { a[k] = aux [i ++]; 4 / 10

5 Merging Trace of merge operation input copy k a[] aux[] i j merged result A A C A C E A C E E A C E E E A C E E E G A C E E E G M A C E E E G M R A C E E E G M R R A C E E E G M R R T A C E E E G M R R T / 10

6 Merge Sort Top-down merge sort package edu. princeton.cs. algs4 ; import java. util. Comparator ; public class Merge { public static void sort ( Comparable [] a) { Comparable [] aux = new Comparable [ a. length ]; sort (a, aux, 0, a. length - 1); private static void sort ( Comparable [] a, Comparable [] aux, int lo, int hi) { if (hi <= lo) { return ; int mid = lo + ( hi - lo) / 2; sort (a, aux, lo, mid ); sort (a, aux, mid + 1, hi ); merge (a, aux, lo, mid, hi ); 6 / 10

7 Merge Sort Trace of merge sort a[] merge(a, aux, 0, 0, 1) merge(a, aux, 2, 2, 3) merge(a, aux, 0, 1, 3) merge(a, aux, 4, 4, 5) merge(a, aux, 6, 6, 7) merge(a, aux, 4, 5, 7) merge(a, aux, 0, 3, 7) merge(a, aux, 8, 8, 9) merge(a, aux, 10, 10, 11) merge(a, aux, 8, 9, 11) merge(a, aux, 12, 12, 13) merge(a, aux, 14, 14, 15) merge(a, aux, 12, 13, 15) merge(a, aux, 8, 11, 15) merge(a, aux, 0, 7, 15) M E R G E S O R T E X A M P L E E M R G E S O R T E X A M P L E E M G R E S O R T E X A M P L E E G M R E S O R T E X A M P L E E G M R E S O R T E X A M P L E E G M R E S O R T E X A M P L E E G M R E O R S T E X A M P L E E E G M O R R S T E X A M P L E E E G M O R R S E T X A M P L E E E G M O R R S E T A X M P L E E E G M O R R S A E T X M P L E E E G M O R R S A E T X M P L E E E G M O R R S A E T X M P E L E E G M O R R S A E T X E L M P E E G M O R R S A E E L M P T X A E E E E G L M M O P R R S T X 7 / 10

8 Merge Sort Top-down merge sort uses N lg N comparisons and N lg N array accesses The prime disadvantage of merge sort is that it uses extra space proportional to N The MergeX variant from the text implements the following improvements Handles tiny subarrays using insertion sort Reduces the running time to be linear for arrays that are already in order by adding a test to skip the call to merge() if a[mid] is less than or equal to a[mid + 1] Eliminates the time taken to copy to the auxiliary array by switching the role of the input and auxiliary array in each recursive call 8 / 10

9 Complexity of Sorting No comparison-based sorting algorithm can guarantee to sort N items with fewer than lg N! N lg N comparisons Proof: Assume array consists of N distinct values a 1 through a N Worst-case number of comparisons is dictated by height h of decision tree Binary tree of height h has at most 2 h leaves N! different orderings = at least N! leaves N! number of leaves 2 h lg N! h, or using Stirling s approximation, N lg N h a b c yes decision tree (for distinct keys a, b, and c) b < c yes a c b yes no a < c a < b no c a b yes b a c no a < c yes b c a height of tree = worst-case number of compares no b < c each leaf corresponds to one (and only one) ordering: (at least) one leaf for each possible ordering no c b a Merge sort is an asymptotically optimal comparison-based sorting algorithm, since the number of comparisons used by merge sort is N lg N 9 / 10

10 Merge Sort and Other Sorts A comparison of merge sort and selection sort $ java SortCompare Merge Selection For random Doubles Merge is 44.8 times faster than Selection A comparison of merge sort and insertion sort $ java SortCompare Merge Insertion For random Doubles Merge is 39.1 times faster than Insertion A comparison of merge sort and shell sort $ java SortCompare Merge Shell For random Doubles Merge is 1.1 times faster than Shell A comparison of merge sort and system sort $ java SortCompare Merge System For random Doubles Merge is 2.0 times faster than System 10 / 10