基本思想

n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：

1. 初始状态：无序区为R[1..n]，有序区为空。
2. 第1趟排序: 在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1] 交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
3. ……
4. 第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];
          }
     }
}

归并排序算法，Python实现，代码如下所示：

class Sorter:
    '''
    Abstract sorter class, which provides shared methods being used by
    subclasses.
    '''
    __metaclass__ = ABCMeta
   
    @abstractmethod   
    def sort(self, array):
        pass

class MergeSorter(Sorter):
    '''
    Merge sorter
    '''
       
    def sort(self, array):
        length = len(array)
        # initialize auxiliary list
        auxiliary_list = [0 for x in range(length)]
        self.__merge_sort(array, auxiliary_list, 0, length - 1)
   
    def __merge_sort(self, array, auxiliary_list, low, high):
        dividedIndex = 0
        if low<high:
            dividedIndex = (low + high) // 2
            self.__merge_sort(array, auxiliary_list, low, dividedIndex)
            self.__merge_sort(array, auxiliary_list, dividedIndex + 1, high)
            self.__merge(array, auxiliary_list, low, dividedIndex, high)
           
    def __merge(self, array, auxiliary_list, low, dividedIndex, high):
        i = low
        j = dividedIndex + 1
        pointer = 0
        while i<=dividedIndex and j<=high:
            if array[i]>array[j]:
                auxiliary_list[pointer] = array[j]
                j = j + 1
            else:
                auxiliary_list[pointer] = array[i]
                i = i + 1
            pointer = pointer + 1
        while i<=dividedIndex:
            auxiliary_list[pointer] = array[i]
            pointer = pointer + 1
            i = i + 1
        while j<=high:
            auxiliary_list[pointer] = array[j]
            pointer = pointer + 1
            j = j + 1
        # copy elements in auxiliary list to the original list
        pointer = 0
        i = low
        while i<=high:
            array[i] = auxiliary_list[pointer]
            i = i + 1
            pointer = pointer + 1

排序过程

假设待排序数组为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)，显然它不是就地排序。

• 排序稳定性

归并排序是一种稳定的排序。