首页 > 代码库 > 排序---归并排序
排序---归并排序
写在前面的话：
一枚自学Java和算法的工科妹子。
- 算法学习书目：算法（第四版） Robert Sedgewick
- 算法视频教程：Coursera Algorithms Part1&2
本文是根据《算法（第四版）》的个人总结，如有错误，请批评指正。
一、归并排序介绍
归并排序（Mergesort）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
归并过程：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到aux[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到aux[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到aux中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。
分治法解题的一般步骤：
（1）分解，将要解决的问题划分成若干规模较小的同类问题；
（2）求解，当子问题划分得足够小时，用较简单的方法解决；
（3）合并，按原问题的要求，将子问题的解逐层合并构成原问题的解。
二、原地归并的抽象方法
将涉及的所有元素复制到一个辅助数组中，再把归并的结果放会原数组中。
图1 原地归并的抽象方法的轨迹
1 private static void merge(Comparable[] a,int lo, int mid, int hi) { 2 // precondition: a[lo .. mid] and a[mid+1 .. hi] are sorted subarrays 3 assert isSorted(a, lo, mid); 4 assert isSorted(a, mid+1, hi); 5 6 // 将a[lo..hi]复制到aux[lo..hi],注意这里的aux[]是全局变量，在方法外已经声明。 7 for (int k = lo; k <= hi; k++) { 8 aux[k] = a[k]; 9 } 10 11 // 归并回a[lo..hi] 12 int i = lo, j = mid+1; 13 for (int k = lo; k <= hi; k++) { 14 if (i > mid) a[k] = aux[j++]; 15 else if (j > hi) a[k] = aux[i++]; 16 else if (less(aux[j], aux[i])) a[k] = aux[j++]; 17 else a[k] = aux[i++]; 18 } 19 20 // postcondition: a[lo .. hi] is sorted 21 assert isSorted(a, lo, hi); 22 }
三、自顶向下的归并排序
图2 自顶向下的归并排序的调用轨迹
1 public class Merge { 2 3 // This class should not be instantiated. 4 private Merge() { } 5 private static Comparable[] aux ; 6 7 // stably merge a[lo .. mid] with a[mid+1 ..hi] using aux[lo .. hi] 8 private static void merge(Comparable[] a, int lo, int mid, int hi) { 9 // precondition: a[lo .. mid] and a[mid+1 .. hi] are sorted subarrays 10 assert isSorted(a, lo, mid); 11 assert isSorted(a, mid+1, hi); 12 13 // copy to aux[] 14 for (int k = lo; k <= hi; k++) { 15 aux[k] = a[k]; 16 } 17 18 // merge back to a[] 19 int i = lo, j = mid+1; 20 for (int k = lo; k <= hi; k++) { 21 if (i > mid) a[k] = aux[j++]; 22 else if (j > hi) a[k] = aux[i++]; 23 else if (less(aux[j], aux[i])) a[k] = aux[j++]; 24 else a[k] = aux[i++]; 25 } 26 27 // postcondition: a[lo .. hi] is sorted 28 assert isSorted(a, lo, hi); 29 } 30 31 public static void sort(Comparable[] a) { 32 aux = new Comparable[a.length]; 33 sort(a, 0, a.length-1); 34 assert isSorted(a); 35 } 36 37 // mergesort a[lo..hi] using auxiliary array aux[lo..hi] 38 private static void sort(Comparable[] a, int lo, int hi) { 39 if (hi <= lo) return; 40 int mid = lo + (hi - lo) / 2; 41 sort(a, lo, mid); 42 sort(a, mid + 1, hi); 43 merge(a, lo, mid, hi); 44 } 45 46 // is v < w ? 47 private static boolean less(Comparable v, Comparable w) { 48 return v.compareTo(w) < 0; 49 } 50 51 private static boolean isSorted(Comparable[] a) { 52 return isSorted(a, 0, a.length - 1); 53 } 54 55 private static boolean isSorted(Comparable[] a, int lo, int hi) { 56 for (int i = lo + 1; i <= hi; i++) 57 if (less(a[i], a[i-1])) return false; 58 return true; 59 } 60 61 // print array to standard output 62 private static void show(Comparable[] a) { 63 for (int i = 0; i < a.length; i++) { 64 StdOut.println(a[i]); 65 } 66 } 67 }
自顶向下归并排序的性能分析：
对于长度为N的任意数组，自顶向下的归并排序需要1/2NlgN至NlgN次比较和6NlgN次访问数组；
（1）比较次数为1/2NlgN至NlgN次的证明（三种证明方法）：
- Proof 1：
- Proof 2：
- Proof 3：
（2）访问数组为6NlgN次证明：每次归并最多需要访问数组次数为6N，其中2N次用来复制，2N次用来比较，2N次用来将比较出来的元素移动会a[].
四、自顶向下的归并排序
图3 自底向上的归并排序的归并结果
1 public class MergeBU { 2 3 // This class should not be instantiated. 4 private MergeBU() { } 5 private static Comparable[] aux; 6 7 // stably merge a[lo..mid] with a[mid+1..hi] using aux[lo..hi] 8 private static void merge(Comparable[] a, int lo, int mid, int hi) { 9 10 // copy to aux[] 11 for (int k = lo; k <= hi; k++) { 12 aux[k] = a[k]; 13 } 14 15 // merge back to a[] 16 int i = lo, j = mid+1; 17 for (int k = lo; k <= hi; k++) { 18 if (i > mid) a[k] = aux[j++]; // this copying is unneccessary 19 else if (j > hi) a[k] = aux[i++]; 20 else if (less(aux[j], aux[i])) a[k] = aux[j++]; 21 else a[k] = aux[i++]; 22 } 23 24 } 25 26 27 public static void sort(Comparable[] a) { 28 int n = a.length; 29 aux = new Comparable[n]; 30 for (int len = 1; len < n; len *= 2) { 31 for (int lo = 0; lo < n-len; lo += len+len) { 32 merge(a, lo, lo+len-1, Math.min(lo+len+len-1, n-1)); 33 } 34 } 35 assert isSorted(a); 36 } 37 38 // is v < w ? 39 private static boolean less(Comparable v, Comparable w) { 40 return v.compareTo(w) < 0; 41 } 42 43 private static boolean isSorted(Comparable[] a) { 44 for (int i = 1; i < a.length; i++) 45 if (less(a[i], a[i-1])) return false; 46 return true; 47 } 48 49 // print array to standard output 50 private static void show(Comparable[] a) { 51 for (int i = 0; i < a.length; i++) { 52 StdOut.println(a[i]); 53 } 54 } 55 }
自底向上归并排序的性能分析：
对于长度为N的任意数组，自底向上的归并排序需要1/2NlgN至NlgN次比较和6NlgN次访问数组；
五、归并排序优化
（1）节省时间（不将元素复制到辅助数组）：在递归调用的每个层次交换数组和辅助数组的角色；
（2）将小数组排序改用插入排序；
（3）比较左边数组的最大值和右边数组的最小值的大小，如果小于，则不需要在归并。
优化后的代码如下：
1 public class MergeX { 2 private static final int CUTOFF = 7; // cutoff to insertion sort 3 4 // This class should not be instantiated. 5 private MergeX() { } 6 7 private static void merge(Comparable[] src, Comparable[] dst, int lo, int mid, int hi) { 8 9 // precondition: src[lo .. mid] and src[mid+1 .. hi] are sorted subarrays 10 assert isSorted(src, lo, mid); 11 assert isSorted(src, mid+1, hi); 12 13 int i = lo, j = mid+1; 14 for (int k = lo; k <= hi; k++) { 15 if (i > mid) dst[k] = src[j++]; 16 else if (j > hi) dst[k] = src[i++]; 17 else if (less(src[j], src[i])) dst[k] = src[j++]; // to ensure stability 18 else dst[k] = src[i++]; 19 } 20 21 // postcondition: dst[lo .. hi] is sorted subarray 22 assert isSorted(dst, lo, hi); 23 } 24 25 private static void sort(Comparable[] src, Comparable[] dst, int lo, int hi) { 26 // if (hi <= lo) return; 27 if (hi <= lo + CUTOFF) { 28 insertionSort(dst, lo, hi); 29 return; 30 } 31 int mid = lo + (hi - lo) / 2; 32 sort(dst, src, lo, mid); 33 sort(dst, src, mid+1, hi); 34 35 // if (!less(src[mid+1], src[mid])) { 36 // for (int i = lo; i <= hi; i++) dst[i] = src[i]; 37 // return; 38 // } 39 40 // using System.arraycopy() is a bit faster than the above loop 41 if (!less(src[mid+1], src[mid])) { 42 System.arraycopy(src, lo, dst, lo, hi - lo + 1); 43 return; 44 } 45 46 merge(src, dst, lo, mid, hi); 47 } 48 49 50 public static void sort(Comparable[] a) { 51 Comparable[] aux = a.clone(); 52 sort(aux, a, 0, a.length-1); 53 assert isSorted(a); 54 } 55 56 // sort from a[lo] to a[hi] using insertion sort 57 private static void insertionSort(Comparable[] a, int lo, int hi) { 58 for (int i = lo; i <= hi; i++) 59 for (int j = i; j > lo && less(a[j], a[j-1]); j--) 60 exch(a, j, j-1); 61 } 62 63 // exchange a[i] and a[j] 64 private static void exch(Object[] a, int i, int j) { 65 Object swap = a[i]; 66 a[i] = a[j]; 67 a[j] = swap; 68 } 69 70 // is a[i] < a[j]? 71 private static boolean less(Comparable a, Comparable b) { 72 return a.compareTo(b) < 0; 73 } 74 75 // is a[i] < a[j]? 76 private static boolean less(Object a, Object b, Comparator comparator) { 77 return comparator.compare(a, b) < 0; 78 } 79 80 public static void sort(Object[] a, Comparator comparator) { 81 Object[] aux = a.clone(); 82 sort(aux, a, 0, a.length-1, comparator); 83 assert isSorted(a, comparator); 84 } 85 86 private static void merge(Object[] src, Object[] dst, int lo, int mid, int hi, Comparator comparator) { 87 88 // precondition: src[lo .. mid] and src[mid+1 .. hi] are sorted subarrays 89 assert isSorted(src, lo, mid, comparator); 90 assert isSorted(src, mid+1, hi, comparator); 91 92 int i = lo, j = mid+1; 93 for (int k = lo; k <= hi; k++) { 94 if (i > mid) dst[k] = src[j++]; 95 else if (j > hi) dst[k] = src[i++]; 96 else if (less(src[j], src[i], comparator)) dst[k] = src[j++]; 97 else dst[k] = src[i++]; 98 } 99 100 // postcondition: dst[lo .. hi] is sorted subarray 101 assert isSorted(dst, lo, hi, comparator); 102 } 103 104 105 private static void sort(Object[] src, Object[] dst, int lo, int hi, Comparator comparator) { 106 // if (hi <= lo) return; 107 if (hi <= lo + CUTOFF) { 108 insertionSort(dst, lo, hi, comparator); 109 return; 110 } 111 int mid = lo + (hi - lo) / 2; 112 sort(dst, src, lo, mid, comparator); 113 sort(dst, src, mid+1, hi, comparator); 114 115 // using System.arraycopy() is a bit faster than the above loop 116 if (!less(src[mid+1], src[mid], comparator)) { 117 System.arraycopy(src, lo, dst, lo, hi - lo + 1); 118 return; 119 } 120 121 merge(src, dst, lo, mid, hi, comparator); 122 } 123 124 // sort from a[lo] to a[hi] using insertion sort 125 private static void insertionSort(Object[] a, int lo, int hi, Comparator comparator) { 126 for (int i = lo; i <= hi; i++) 127 for (int j = i; j > lo && less(a[j], a[j-1], comparator); j--) 128 exch(a, j, j-1); 129 } 130 131 private static boolean isSorted(Comparable[] a) { 132 return isSorted(a, 0, a.length - 1); 133 } 134 135 private static boolean isSorted(Comparable[] a, int lo, int hi) { 136 for (int i = lo + 1; i <= hi; i++) 137 if (less(a[i], a[i-1])) return false; 138 return true; 139 } 140 141 private static boolean isSorted(Object[] a, Comparator comparator) { 142 return isSorted(a, 0, a.length - 1, comparator); 143 } 144 145 private static boolean isSorted(Object[] a, int lo, int hi, Comparator comparator) { 146 for (int i = lo + 1; i <= hi; i++) 147 if (less(a[i], a[i-1], comparator)) return false; 148 return true; 149 } 150 151 // print array to standard output 152 private static void show(Object[] a) { 153 for (int i = 0; i < a.length; i++) { 154 StdOut.println(a[i]); 155 } 156 } 157 }
六、归并排序总结
归并排序是一种渐进最优的基于比较的排序算法，归并排序在最坏的情况下的比较次数为~NlgN，这是其他排序算法复杂度的上限。详细证明可以见算法（第四版）pp.177-178
作者： 邹珍珍（Pearl_zhen）
出处： http://www.cnblogs.com/zouzz/
声明：本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出 原文链接 如有问题， 可邮件（zouzhenzhen@seu.edu.cn）咨询.
排序---归并排序
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。