排序算法——归并排序

归并排序

• 时间复杂度：O(nlogn)
• 最坏时间复杂度： O(nlgn)
• 最好时间复杂度： O(nlgn)
• 空间复杂度：O(n)
• 稳定

两路归并算法思路：

分而治之(divide - conquer);每个递归过程涉及三个步骤

1. 分解: 把待排序的 n 个元素的序列分解成两个子序列, 每个子序列包括 n/2 个元素.
2. 治理: 对每个子序列分别调用归并排序MergeSort, 进行递归操作
3. 合并: 合并两个排好序的子序列,生成排序结果.

代码实现：

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {2, 3, 5, 7, 8, 1, 4, 6, 9};
        sort(arr, 0, arr.length - 1);
        Common.print(arr);
    }

    public static void sort(int[] arr, int start, int end) {
        if (start == end) return;
        int mid = start + (end - start) / 2;
        sort(arr, start, mid);
        sort(arr, mid + 1, end);
        merge(arr, start, mid + 1, end);
    }

    private static void merge(int[] arr, int leftPtr, int rightPtr, int bound) {
        int i = leftPtr;
        int j = rightPtr;
        int k = 0;
        int[] temp = new int[bound - leftPtr + 1];

        while (i < rightPtr && j <= bound)
            temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
        while (i < rightPtr)
            temp[k++] = arr[i++];
        while (j <= bound)
            temp[k++] = arr[j++];
        System.arraycopy(temp, 0, arr, leftPtr, temp.length);
    }
}

算法分析

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