數據結構與算法學習筆記——歸併排序、快速排序

歸併排序

原理

歸併排序是用了分而治之的思想，原理對照下邊我畫的圖看很簡單，將數組分成前後兩部分，然後分別對這兩部分排序，排序好之後再合併起來。

而在代碼中我們需要用到遞歸來實現。衆所周知，遞歸先要找到遞推公式和終止條件。

• 遞推公式：sort(start, end) = merge(sort(start, mid), sort(mid + 1, end);

• 終止條件：start >= end

其中：

• mid = (start + end ) / 2;
• sort 方法是將數組拆分成兩部分分別排序
• merge 方法是將兩個排好序的數組合併成一個數組

代碼

    private static void sortArray(int[] arr) {
        // 創建與 arr 等長的臨時數組
        int[] temp = new int[arr.length];
        // 調用排序算法
        sort(arr, 0, arr.length - 1, temp);
    }

    private static void sort(int[] arr, int start, int end, int[] temp) {
        // 遞歸終止條件 拆到數組只有一個元素時，start = end
        if (start >= end) {
            return; // 結束遞歸
        }
        // 假設數組是｛0，1｝,start = 0, end = 1, mid = 0
        int mid = (start + end) / 2;
        // 對左邊排序
        sort(arr, start, mid, temp);
        // 對右邊排序
        sort(arr, mid + 1, end, temp);
        // 合併
        merge(arr, start, mid, end, temp);
    }

    private static void merge(int[] arr, int start, int mid, int end, int[] temp) {
        // i，j 爲左列、右列各自第一個元素下標， k 爲 temp 臨時數組對應下標
        int i = start, j = mid + 1, k = start;

        // 順序依次比較左、右列的元素，從小到大放入 臨時數組對應位置
        // 如果任一列元素遍歷完，就停止遍歷
        while (i <= mid && j <= end) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }

        // 把左列或右列剩下沒有進行遍歷賦值的元素賦值到 temp 中
        while (i <= mid) {
            temp[k++] = arr[i++];
        }
        while (j <= end) {
            temp[k++] = arr[j++];
        }

        // 把本次合併區間排列好的元素從temp賦值到arr中
        for (int x = start; x <= end; x++) {
            arr[x] = temp[x];
        }
    }

分析

• 穩定性：合併時如果有相等的元素，先將前列的數據放入temp數組，保證有序性，是穩定的排序算法。
• 空間複雜度：需要一個臨時數組 temp 來存放數據，空間複雜度O(n)。
• 時間複雜度：具體算法不寫了，歸併排序的時間複雜度與數組的有序程度無關，不管最好、最壞還是平均，時間複雜度都是O(nlogn)。

快速排序

原理

快速排序和歸併排序很相似，也用到了分治、遞歸，甚至連遞推公式都是一樣的。但思路其實並不相同，快排的主要思想是，我們隨便選擇一個數組中的元素作爲中間點，遍歷數組，將小於中間點的元素放在左邊，大於中間點的元素放在右邊，中間點放在中間。這樣繼續對前半部分和後半部分分別做一樣的操作，直到無法分隔，這時數組就是有序的了。如圖所示：一般情況選末尾的元素作爲中間點。

我們繼續深入思考，具體如何實現這個過程呢？不考慮空間消耗，可以每次拆分都創建兩個臨時數組，遍歷將元素挨個放進去，然後再合併回來。

我們可以發現，歸併排序並沒有辦法做到本地排序，那快速排序有沒有辦法呢？來看下邊這張圖，用到了和選擇排序有點類似的技巧。以末尾的5爲區分，遍歷數組比較，比它小的插在前邊，比它大的插在後邊。

但往數組中插入元素需要把很多元素向後移一位，很耗時。同樣我們可以用交換代替插入，具體過程如圖：選中末尾的5爲中間點，用遊標i標記小於5的部分，遊標k表示當前遍歷元素。拿k指向的元素和5去比較，如果小於5，就和i指向的元素交換位置。繼續遍歷，最後將k指向的5和i指向的元素交換位置，讓中間元素位於兩個部分的中間。

從這個過程中也可以看出，快排不是一個穩定的排序算法。

代碼

    private static void sortArray(int[] arr) {
        sort(arr, 0, arr.length - 1);
    }

    private static void sort(int[] arr, int start, int end) {

        // 遞歸結束條件
        if (start >= end) {
            return;
        }

        // 分區，返回分區中間點下標
        int p = part(arr, start, end);

        // 繼續分別排序中間點前後數組
        sort(arr, start, p - 1);
        sort(arr, p + 1, end);
    }

    private static int part(int[] arr, int start, int end) {

        // 標記小於中間點區間的結尾
        int i = start;
        
        // 選尾部元素爲中間點
        int p = arr[end];

        // 遍歷，如果比中間點小，就插入小於區間的末尾
        for (int k = start; k < end; k++) {
            if (arr[k] < p) {
                swap(arr, i, k);
                i++;
            }
        }
        // 遍歷結束後把中間點放到它應該在的位置
        swap(arr, i, end);
        return i;
    }

    /**
     * 數組元素交換位置
     */
    private static void swap(int[] arr, int i, int k) {
        int temp = arr[i];
        arr[i] = arr[k];
        arr[k] = temp;
    }

分析

• 穩定性：非穩定排序算法。
• 空間複雜度：利用上文圖中的巧妙算法，我們做到了本地排序，空間複雜度O(1)。
• 時間複雜度：基本同歸並排序，只有在極端情況下（比如已經是有序數組，我們選擇最後一個元素作爲中間點）會退化成O(n²)。在大部分情況下，時間複雜度是O(nlogn)

結語

代碼一定要自己想着寫一遍，會理解、記憶的更清楚。原理看着簡單，但轉爲代碼時就會變得一頭霧水。另外很多關於邊界的判斷一不留神就出bug了。