Java 排序算法-归并排序

算法思想

归并排序（MergeSort）是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

算法原理

归并算法的示意图（图片来自维基百科）

算法实现

使用递归的归并排序

public class TestJava {    private static int[] array = new int[]{11, 4, 5, 6, 1, 2, 16, 3, 44, 21, 22, 8, 9, 7, 2, 6};    public static void main(String[] args) {        mergeSort(array, 0, array.length - 1);        for (int k : array) {            System.out.println("array:" + k);        }    }    private static void mergeSort(int[] array, int left, int right) {        if (left >= right) {            return;        }        int middle = (left + right) / 2;        int[] A = new int[middle - left + 1];        int[] B = new int[right - middle];        System.arraycopy(array, left, A, 0, A.length);        System.arraycopy(array, middle + 1, B, 0, B.length);        mergeSort(A, 0, A.length -1);        mergeSort(B, 0, B.length - 1);        int i = 0;        int j = 0;        for (int index = left; index <= right; index++) {            if (i < A.length && j < B.length) {                array[index] = A[i] < B[j] ?  A[i ++] : B[j ++];            } else if (i < A.length) {                array[index] = A[i ++];            } else if (j < B.length) {                array[index] = B[j ++];            }        }    }}

归并排序的优化（非递归归并排序）

public class CustomMergeSort {    private static int[] array = new int[]{11, 4, 5, 6, 1, 2, 16, 3, 44, 21, 22, 8, 9, 7, 2, 6};    public static void main(String[] args) {        mergeSort();        for (int i : array) {            System.out.println(i);        }    }    public static void mergeSort() {        int len = array.length;        int k = 1;        while (k < len) {            mergePass(array, k, len);            k *= 2;        }    }    private static void mergePass(int[] array, int k, int n) {        int i = 0;        while (i < n - 2 * k + 1) {            merge(array, i , i + 2 * k - 1);            i += 2* k;        }        if (i < n - k) {            merge(array, i, n -1);        }    }    private static void merge(int[] array, int left, int right) {        if (left >= right) {            return;        }        int middle = (left + right) / 2;        int[] A = new int[middle - left + 1];        int[] B = new int[right - middle];        System.arraycopy(array, left, A, 0, A.length);        System.arraycopy(array, middle + 1, B, 0, B.length);        int i = 0;        int j = 0;        for (int index = left; index <= right; index++) {            if (i < A.length && j < B.length) {                array[index] = A[i] < B[j] ?  A[i ++] : B[j ++];            } else if (i < A.length) {                array[index] = A[i ++];            } else if (j < B.length) {                array[index] = B[j ++];            }        }    }}

算法分析

（1）稳定性
　归并排序是一种稳定的排序。
（2）存储结构要求
　可用顺序存储结构。也易于在链表上实现。
（3）时间复杂度
　对长度为n的文件，需进行 趟二路归并，每趟归并的时间为O(n)，故其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlgn)。
（4）空间复杂度
　 需要一个辅助向量来暂存两有序子文件归并的结果，故其辅助空间复杂度为O(n)，显然它不是就地排序。