基本思想
n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：
初始状态：无序区为R[1..n]，有序区为空。第1趟排序: 在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1] 交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。……第i趟排序: 第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R[i..n](1≤i≤n-1)。 该趟排序从当前无序区中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[i]交换，使R[1..i] 和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。
算法实现
归并排序算法，java实现，代码如下所示：
public abstract class Sorter { public abstract void sort(int[] array); } public class MergeSorter extends Sorter { @Override public void sort(int[] array) { int[] auxArray = new int[array.length]; mergeSort(array, auxArray, 0, array.length - 1); } /** * 基于分治思想，执行归并排序 * @param low 待排序数组下标下界 * @param high 待排序数组下标上界 */ PRivate void mergeSort(int[] array, int[] auxArray, int low, int high) { int dividedIndex = 0; // 分治位置索引变量 if (low < high) { dividedIndex = (low + high) / 2; // 计算分治位置(采用简单的二分思想) mergeSort(array, auxArray, low, dividedIndex); // 左侧递归归并排序 mergeSort(array, auxArray, dividedIndex + 1, high); // 右侧递归归并排序 merge(array, auxArray, low, dividedIndex, high); // 合并分治结果 } } private void merge(int[] array, int[] auxArray, int low, int dividedIndex, int high) { int i = low; // 指向左半分区数组的指针 int j = dividedIndex + 1; // 指向右半分区数组的指针 int auxPtr = 0; // 指向辅助区数组的指针 // 合并两个有序数组：array[low..dividedIndex]与array[dividedIndex+1..high]。 while (i <= dividedIndex && j <= high) { // 将两个有序的数组合并，排序到辅助数组auxArray中 if (array[i] > array[j]) { // 左侧数组array[low..dividedIndex]中的array[i]大于右侧数组array[dividedIndex+1..high]中的array[j] auxArray[auxPtr++] = array[j++]; } else { auxArray[auxPtr++] = array[i++]; } } // 如果array[low..dividedIndex].length>array[dividedIndex+1..high].length，经过上面合并 // array[low..dividedIndex]没有合并完，则直接将array[low..dividedIndex]中没有合并的元素复制到辅助数组auxArray中去 while (i <= dividedIndex) { auxArray[auxPtr++] = array[i++]; } // 如果array[low..dividedIndex].length<array[dividedIndex+1..high].length，经过上面合并 // array[dividedIndex+1..high]没有合并完，则直接将array[dividedIndex+1..high]中没有合并的元素复制到辅助数组auxArray中去 while (j <= high) { auxArray[auxPtr++] = array[j++]; } // 最后把辅助数组auxArray的元素复制到原来的数组中去，归并排序结束 for (auxPtr = 0, i = low; i <= high; i++, auxPtr++) { array[i] = auxArray[auxPtr]; } } }排序过程
假设待排序数组为array = {94,12,34,76,26,9,0,37,55,76,37,5,68,83,90,37,12,65,76,49}，数组大小为20，我们以该数组为例，执行归并排序的具体过程，如下所示：
[94,12,34,76,26,9,0,37,55,76, 37,5,68,83,90,37,12,65,76,49] [94,12,34,76,26, 9,0,37,55,76] [94,12,34, 76,26] [94,12, 34] [94, 12] {12, 94} {12,34, 94} [76, 26] {26, 76} {12,26,34, 76,94} [9,0,37, 55,76] [9,0, 37] [9, 0] {0, 9} {0,9, 37} [55, 76] {55, 76} {0,9,37, 55,76} {0,9,12,26,34, 37,55,76,76,94} [37,5,68,83,90, 37,12,65,76,49] [37,5,68, 83,90] [37,5, 68] [37, 5] {5, 37} {5,37, 68} [83, 90] {83, 90} {5,37,68, 83,90} [37,12,65, 76,49] [37,12, 65] [37, 12 ] {12, 37 } {12,37, 65 } [76, 49 ] {49, 76} {12,37,49, 65,76} {5,12,37,37,49, 65,68,76,83,90} {0,5,9,12,12,26,34,37,37,37, 49,55,65,68,76,76,76,83,90,94}上面示例的排序过程中，方括号表示“分解”操作过程中，将原始数组进行递归分解，直到不能再继续分割为止；花括号表示“归并”的过程，将上一步分解后的数组进行归并排序。因为采用递归分治的策略，所以从上面的排序过程可以看到，“分解”和“归并”交叉出现。
算法分析
时间复杂度对长度为n的文件，需进行FLOOR(logn) 趟二路归并，每趟归并的时间为O(n)，故其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlgn)。
空间复杂度需要一个辅助向量来暂存两有序子文件归并的结果，故其辅助空间复杂度为O(n)，显然它不是就地排序。
排序稳定性归并排序是一种稳定的排序。
新闻热点
疑难解答
