三種高階比較排序演算法

Junpb發表於2018-07-29
排序演算法

時間複雜度的估算

這三種排序演算法都是利用在遍歷過程中在一定程度上排序的同時記錄儘可能多的元素有關位置的資訊。

master表示式：用於對採用遞迴實現的相關演算法的時間複雜度的估算

Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜…＜Ο(2n)＜Ο(n!)

T(N)=aT(N/b)+N^d

log_ab=d時:T(N)=O(N*logN)

1.歸併排序

1.1思想

時間複雜度:O(N*logN)

空間複雜度:N

文字敘述：歸併排序採用將陣列拆分為左右兩項，左右兩部分各自內部保證相對有順序，左右兩邊按照雙指標的指示，採取排序規則，將新排好的資料插入新申請的陣列內部，最後將中間排好序的陣列放回原陣列。

要點如下： 1.申請輔助空間儲存排好序的新陣列。

​ 2.對超出對比的部分直接放入輔助空間。

​ 3.將輔助空間內的資料賦值回原陣列時，注意陣列下標。

tips：mid=l+((r-1)>>1)，這樣可以有效避免溢位問題。並炫技。

1.2程式碼

public static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        mergeSort(arr, 0, arr.length - 1);
    }
​
    private static void mergeSort(int[] arr, int l, int r) {
​
        if (l == r) {
            return;
        }
        int mid = (l + r) / 2;
        mergeSort(arr, l, mid);
        mergeSort(arr, mid + 1, r);
        merge(arr, l, mid, r);
    }
​
    private static void merge(int[] arr, int l, int mid, int r) {
​
        int[] tmp = new int[r - l + 1];
        int p1 = l;
        int p2 = mid + 1;
        int i = 0;
        while (p1 <= mid && p2 <= r) {
            // 這裡的<=保證了演算法的穩定性
            tmp[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
        }
        while (p1 <= mid) {
            tmp[i++] = arr[p1++];
        }
        while (p2 <= r) {
            tmp[i++] = arr[p2++];
        }
        // 將輔助陣列中的數進行拷貝到原陣列中
        for (int j = 0; j < tmp.length; j++) {
            arr[l + j] = tmp[j];
        }
    }

2.快速排序

2.1思想

時間複雜度:O(N*logN)

空間複雜度:logN

這裡空間複雜度需要加深理解，這是由於在遞迴過程中，必須有每次有一個變數記錄partition返回的陣列位置。為方便理解，可以認為在每次都返回中間位置mid的情況下，這是一個類似二分的過程，所以為logN。

文字敘述：快速排序採用每次選出一個標誌位，並將陣列按照標誌位的大小分為大於與不大於（小於等於）兩部分，逐次將陣列排序好。

演算法優化： 1.通過random抵消每次出現partition最壞情況的出現，即每次都是分在頭上，只排序好一個位置的

元素。

​ 2.採用荷蘭國旗經典問題的啟示，將陣列從原來的分為兩組，變成分為三組，即小於，等於，大於這三個部分，這樣等於在一次遍歷後可以認為一次排好序了相同元素個數的元素，在只要有相同元素存在的情況都會降低一定複雜度。

圖片敘述：

2.2程式碼

// 快速排序,這裡直接寫改進過後的快速排序（荷蘭國旗問題：< = > ）
    public static void quickSort(int[] arr) {
​
        if (arr == null || arr.length < 2) {
            return;
        }
        quickSort(arr, 0, arr.length - 1);
    }
​
    private static void quickSort(int[] arr, int l, int r) {
​
        if (l < r) {
            int p[] = partition(arr, l, r);
            quickSort(arr, l, p[0]);
            quickSort(arr, p[1], r);
        }
​
    }
​
    private static int[] partition(int[] arr, int l, int r) {
​
        int less = l - 1;
        int more = r;
        // 這裡分為三種區域：< = > 邊界為。。less less。。l more。。
        while (l < more) {
            if (arr[l] < arr[r]) {
                swap(arr, ++less, l++);
            } else if (arr[l] == arr[r]) {
                l++;
            } else {
                swap(arr, l, --more);
            }
        }
        // 再將評分標準arr[r]換回=區.結束排序
        swap(arr, more++, r);
        // 這裡返回的是=區的兩側邊界的兩側，即如果要求等於區有多少元素的話，應該為 more-less-1
        return new int[] { less, more };
    }
​
    public static void swap(int[] arr, int l, int r) {
        int tmp = arr[l];
        arr[l] = arr[r];
        arr[r] = tmp;
    }// 由於第一次寫這種思想的快速排序，耗時較長，花費35分鐘，需要加強練習。
​
    // 堆排序，堆排序總體上看分為兩個過程，建立大根堆與堆的重新建立
​

 

3.堆排序

3.1思想

時間複雜度:O(N*logN)

空間複雜度:1

對於一個節點n，如果有左右孩子節點

​ 左孩子：2n+1

​ 右孩子：2n+2

對於一個節點n，如果有父節點

​ 父節點：(n-1)/2

文字敘述：堆排序演算法採用堆的思想，主題分為兩部分：建立大根堆與堆的重建立。

堆：即完全二叉樹，與陣列相互建立聯絡，因為陣列是一個接一個的，不可能出現null，所以一定是一個從上到下，從左至右將樹填滿的過程，借用二叉樹優秀的資料結構，將排序的複雜度降低。

堆的建立：從左至右依次遍歷，並一步步建立堆，新加進來的元素需要與父節點比較，並上升至直到頂點，注意下部分程式碼的判斷條件，一步實現了兩種邊界判斷的優秀程式碼。總結，堆的建立時一個節點上升的過程，不需要考慮陣列的下界限問題（這裡指樹結構時的上下）。

堆的重建立：堆的重建立是建立在一次次將根節點與陣列最後節點交換的情況下，剩下元素（不包括剛剛交換下來的前根節點，因為在大根堆的情況下已經可以保證之前根節點一定為陣列內最大）的大根堆重建立，這裡新的根節點需要判斷是否比其孩子節點的最大值小（如果有孩子節點，這裡孩子節點只需要判斷左孩子節點，因為是完全二叉樹，一定有左孩子節點，而不一定有右孩子節點），這樣當大根堆重建立的時候又可以保證根節點的最大，依次完成所有根節點的pop。總結，堆的重建立是一個根節點的下落過程，不需要考慮上邊界的越界。

3.2程式碼

// 堆排序，堆排序總體上看分為兩個過程，建立大根堆與堆的重新建立
​
    public static void heapSort(int[] arr) {
​
        if (arr == null || arr.length < 2) {
            return;
        }
        heapSort(arr, 0, arr.length - 1);
    }
​
    private static void heapSort(int[] arr, int l, int r) {
​
        for (int i = l; i <= r; i++) {
            heapInsert(arr, i);
        }
        int size = arr.length;
        swap(arr, 0, --size);
        while (size > 0) {
            heapify(arr, 0, size);
            swap(arr, 0, --size);
        }
​
    }
​
    private static void heapInsert(int[] arr, int i) {
        while (arr[(i - 1) / 2] < arr[i]) {// 這條是大神寫的，竟然可以控制上限，請仔細思考
            swap(arr, (i - 1) / 2, i);
            i /= 2;
        }
    }
​
    private static void heapify(int[] arr, int i, int size) {
        int left = i * 2 + 1;
        while (left < size) {
            int largest = left + 1 < size && arr[left] < arr[left + 1] ? left + 1 : left;//程式設計美不美？
            largest = arr[largest]>arr[i]?largest:i;
            if(largest==i) {
                break;
            }
            swap(arr, i, largest);
            i = largest;
            left = i*2+1;
        }
​
    }
​

 

4.演算法的穩定性

演算法的穩定性籠統上來說就是在排序過後相等的各元素是否保持相對順序不變，這在簡單資料型別中不必考慮，沒有意義，但是複雜資料型別就有了相應的應用環境，比如電商平臺商品的篩選，需求：在搜尋商品後，填上篩選條件，選擇了價格排序的同時，我希望相同種類的商品相對位置不變。或者說，在成績排名這個場景中，我先拍好了全校的成績，但是需要分為班級，這時我不希望每個班級中學生成績又變成亂亂的，我希望還是按照之前學校成績排好的那種相對位置不變，就可以直接排好每個班級的成績。

以下是不穩定的排序演算法的某些例子，可自行思考。

選擇排序：[5,5,5,1,5]

快速排序：[7,7,7,3,5]

堆排序：[4,3,3,5]

 

5.工程上混合排序演算法的優化

1.簡單資料型別使用快速排序，複雜資料型別使用歸併排序，這是考慮到演算法的穩定性。並且需要補充的是，快速排序是時間複雜度為O(N*logN)的三種排序演算法中常數項最少的，即是這三種演算法中最快的。

2.快速排序的使用時，中間遞迴的結束條件不以簡單的if(L==R)為結束，而是將簡單排序與複雜排序相結合，使用插入排序，判斷條件為所要排序演算法的規模，預設為60個。我認為，這是由於遞迴對棧空間的大量佔用，以及時間複雜度在資料量小的時候體現不明顯甚至有可能還不如插入排序。

下篇將介紹簡單排序與非比較排序（桶排序的簡單介紹）

相關文章