歸併排序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
*/