归并排序Java代码实现

归并排序

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n)的时间复杂度。代价是需要额外的内存空间。

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

算法描述

1. 把长度为 n 的输入序列分成两个长度为 n / 2 的子序列；
2. 对这两个子序列分别采用归并排序；
3. 将两个排序好的子序列合并成一个最终的排序序列。

算法分析

• 最佳情况：T(n) = O(nlogn)
• 空间复杂度： O(n)
• 稳定性： 稳定

代码实现

public class MergeSort {
    public static void mergeSort(int[] arr) {
        // 空数组 或 只有一个元素的数组，则什么都不做。
        if (arr == null || arr.length <= 1) return;
        mergeSort(arr, 0, arr.length - 1);
    }

    private static void mergeSort(int[] arr, int low, int high) {
        if (low >= high) return;

        // 计算出中间值，这种算法保证不会溢出。
        int mid = low + ((high - low) >> 1);
        // 先对左边排序
        mergeSort(arr, low, mid);
        // 先对右边排序
        mergeSort(arr, mid + 1,high);

        // 归并两个有序的子序列
        merge(arr, low, mid, high);

        // 把每一趟排序的结果也输出一下。
        print(arr);
    }

    private static void merge(int[] arr, int low, int mid, int high) {
        // temp[]是临时数组，包左不包右，所以要额外 + 1。
        int[] temp = new int[high - low + 1];
        int left = low; // 左侧指针从low开始。
        int right = mid + 1;    // 右侧指针从mid+1开始。
        int index = 0;  // 此索引用于temp[]
        // 当两个子序列还有元素时，从小到大放入temp[]中。
        while (left <= mid && right <= high) {
            if (arr[left] < arr[right]) {
                temp[index++] = arr[left++];
            } else {
                temp[index++] = arr[right++];
            }
        }

        // 要么左边没有元素
        while (left <= mid) {
            temp[index++] = arr[left++];
        }

        // 要么右边没有元素
        while (right <= high) {
            temp[index++] = arr[right++];
        }

        // 重新赋值给arr对应的区间。
        for (int i = 0; i < temp.length; i++) {
            arr[low + i] = temp[i];
        }
    }

    public static void main(String[] args) {
        int[] arr = {6, 9, 1, 4, 5, 8, 7, 0, 2, 3};

        System.out.print("排序前:  ");
        print(arr);

        mergeSort(arr);

        System.out.print("排序后:  ");
        print(arr);
    }

    // 打印数组
    public static void print(int[] arr) {
        if (arr == null)    return;

        for(int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}
/*
排序前:  6 9 1 4 5 8 7 0 2 3 
6 9 1 4 5 8 7 0 2 3 
1 6 9 4 5 8 7 0 2 3 
1 6 9 4 5 8 7 0 2 3 
1 4 5 6 9 8 7 0 2 3 
1 4 5 6 9 7 8 0 2 3 
1 4 5 6 9 0 7 8 2 3 
1 4 5 6 9 0 7 8 2 3 
1 4 5 6 9 0 2 3 7 8 
0 1 2 3 4 5 6 7 8 9 
排序后:  0 1 2 3 4 5 6 7 8 9
*/