排序算法雜談（五） —— 關於快速排序的優化策略分析

1. 前提

排序算法（六） —— 歸並排序

排序算法（七） —— 快速排序

排序算法雜談（四） —— 快速排序的非遞歸實現

 

 

2. 優化策略1：主元（Pivot）的選取

歸並排序（Merge Sort）有一個很大的優勢，就是每一次的遞歸都能夠將數組平均二分，從而大大減少了總遞歸的次數。

而快速排序（Quick Sort）在這一點上就做的很不好。

快速排序是通過選擇一個主元，將整個數組划分（Partition）成兩個部分，小於等於主元 and 大於等於主元。

這個過程對於數組的划分完全就是隨機的，俗稱看臉吃飯。

這個划分是越接近平均二分，那么這個划分就越是優秀；而若果不巧取到了數組的最大值或是最小值，那這次划分其實和沒做沒有什么區別。

 

因此，主元的選取，直接決定了一個快速排序的效率。

通過之前快速排序的學習，我們知道了基本上有兩種主流的划分方式，我將其稱之為：

• 挖坑取數
• 快慢指針

前者將最左側的數作為主元，后者將最右側的數作為主元，這種行為完全就是隨機取數。

 

最簡單的的方法，就是在范圍內取一個隨機數，但是這種方法從概率的角度上來說，和之前的沒有區別。

進一步的思考，可以從范圍內隨機取出三個數字，找到三個數字的中位數，然后和原主元的位置進行交換。

將中位數作為主元，相比於隨機取出的另外兩個數字，對於划分的影響還是很明顯的。

 

package com.gerrard.sort.compare.quick.partition.pivot;

import com.gerrard.util.RandomHelper;

public final class MediumPivot implements Pivot {

    @Override
    public int getPivotIndex(int[] array, int left, int right) {
        int index1 = RandomHelper.randomBetween(left, right);
        int index2 = RandomHelper.randomBetween(left, right);
        int index3 = RandomHelper.randomBetween(left, right);
        if (array[index1] > array[index2]) {
            if (array[index2] > array[index3]) {
                return index2;
            } else {
                return array[index1] > array[index3] ? index3 : index1;
            }
        } else {
            if (array[index1] > array[index3]) {
                return index3;
            } else {
                return array[index2] > array[index3] ? index3 : index2;
            }
        }
    }
}

 

 

3. 優化策略2：閾值的選取

同樣是參考歸並排序的優化策略，歸並排序可以通過判斷數組的長度，設定一個閾值。

數組長度大於閾值的，使用歸並排序策略。

數組長度小於閾值的，使用直接插入排序。

通過這種方式，歸並排序避免了針對小數組時候的遞歸（遞歸層次增加最多的場景，就是大量的小數組），從而減輕了JVM的負擔。

 

public class OptimizedQuickSort implements Sort {

    private ThreeWayPartition partitionSolution = new ThreeWayPartition();
    private int threshold = 2 << 4;

    public void setPartitionSolution(ThreeWayPartition partitionSolution) {
        this.partitionSolution = partitionSolution;
    }

    public void setThreshold(int threshold) {
        this.threshold = threshold;
    }

    @Override
    public void sort(int[] array) {
        sort(array, 0, array.length - 1);
    }

    private void sort(int[] array, int left, int right) {
        if (right - left < threshold) {
            insertionSort(array, left, right);
        } else if (left < right) {
            int[] partitions = partitionSolution.partition(array, left, right);
            sort(array, left, partitions[0] - 1);
            sort(array, partitions[1] + 1, right);
        }
    }

    private void insertionSort(int[] array, int startIndex, int endIndex) {
        for (int i = startIndex + 1; i <= endIndex; ++i) {
            int cur = array[i];
            boolean flag = false;
            for (int j = i - 1; j > -1; --j) {
                if (cur < array[j]) {
                    array[j + 1] = array[j];
                } else {
                    array[j + 1] = cur;
                    flag = true;
                    break;
                }
            }
            if (!flag) {
                array[0] = cur;
            }
        }
    }
}

 

 

4. 優化策略3：三路划分

從上面的代碼中，我們可以看到一個 ThreeWayPartition，這就是現在要講的三路划分。

回顧之前的快速排序划分的描述：

快速排序是通過選擇一個主元，將整個數組划分成兩個部分，小於等於主元 and 大於等於主元。

 

不難發現，一次划分之后，我們將原數組划分成了三個部分，小於等於主元 and 主元 and 大於等於主元，划分結束之后，再將主元兩側進行遞歸。

由此可見，等於主元的部分被划分到了三個部分，那么我們就有了這樣的思考：

能不能將數組明確地划分成三個部分：小於主元 and 主元和等於主元 and 大於主元。

這樣一來，等於主元的部分就直接從下一次的遞歸中去除了。

 

回看一下 “挖坑取數” 的代碼：

    @Override
    public int partition(int[] array, int left, int right) {
        int pivot = array[left];
        int i = left;
        int j = right + 1;
        boolean forward = false;
        while (i < j) {
            while (forward && array[++i] <= pivot && i < j) ;
            while (!forward && array[--j] >= pivot && i < j) ;
            ArrayHelper.swap(array, i, j);
            forward ^= true;
        }
        return j;
    }

 

在內循環中，我們的判斷條件是： array[++i] <= pivot。

在這個基礎上，再做一次判斷，針對等於 pivot 的情況，將等於 pivot 的值，與一個已經遍歷過的位置交換：

• 從左往右找大於 pivot 的值時，與數組開頭部分交換。
• 從右往左找小於 pivot 的值時，與數組結束部分交換。

 

那么，在整個划分結束之后，我們會得到這么一個數據模型：

其中：

• 等於 pivot：[left,p) & i & (q,right]
• 小於 pivot：[p,i)
• 大於 pivot：(j,q]

然后將 left->p 的數據依次交換到 i 的左側，同理，將q->right 的數據依次交換到 j 的右側。

這樣我們就能得到整個數組關於 pivot 的嚴格大小關系：

• 等於 pivot：[p',q']
• 小於 pivot：[left,p')
• 大於 pivot：(q',right]

 

package com.gerrard.sort.compare.quick.partition;

import com.gerrard.sort.compare.quick.partition.pivot.Pivot;
import com.gerrard.util.ArrayHelper;

/**
 * Three-Way-partition is an optimized solution for partition, also with complexity O(n).
 * It directly separate the original array into three parts: smaller than pivot, equal to pivot, larger than pivot.
 * It extends {@link SandwichPartition} solution.
 *
 * Step1: Select the left one as pivot.
 * Step2: Besides i and j, define two more index p and q as two sides index.
 * Step3: Work as SandwichPartition, from sides->middle, the only difference is:
 *        when meeting equal to pivot scenario, swap i and p or j and q.
 *
 * Step4: After iterator ends, the array should look like:
 *
 *        left                   i=j                     right
 *        ---------------------------------------------------
 *        |     |           |     |     |               |   |
 *        ---------------------------------------------------
 *              p           p'          q'              q
 *
 *        The distance between left->p and p'->i should be same.
 *        The distance between j->q' and q->right should also be same.
 *        [left,p) and (q,right] is equal to pivot, [p,i) is smaller than pivot, (j,q] is larger than pivot.
 *
 * Step5: Exchange [left,p) and [p',i), exchange (q,right] and (j,q'].
 * Step6: Returns two number p'-1 and q'+1.
 *
 */
public final class ThreeWayPartition {

    public int[] partition(int[] array, int left, int right) {
        if (pivotSolution != null) {
            int newPivot = pivotSolution.getPivotIndex(array, left, right);
            ArrayHelper.swap(array, left, newPivot);
        }
        int pivot = array[left];
        int i = left;
        int j = right + 1;
        int p = i;
        int q = j - 1;
        boolean forward = false;
        while (i < j) {
            while (forward && array[++i] <= pivot && i < j) {
                if (array[i] == pivot) {
                    ArrayHelper.swap(array, i, p++);
                }
            }
            while (!forward && array[--j] >= pivot && i < j) {
                if (array[j] == pivot) {
                    ArrayHelper.swap(array, j, q--);
                }
            }
            ArrayHelper.swap(array, i, j);
            forward ^= true;
        }
        while (p > left) {
            ArrayHelper.swap(array, --p, --i);
        }
        while (q < right) {
            ArrayHelper.swap(array, ++q, ++j);
        }
        return new int[]{i, j};
    }
}

 

 

5. 優化測試

最后，針對各種快速排序的算法，我做了一系列的性能測試：

package com.gerrard.helper;

import com.gerrard.sort.Sort;

public final class ComparableTestHelper {

    private ComparableTestHelper() {

    }

    public static void printCompareResult(int[] array, Sort... sorts) {
        for (Sort sort : sorts) {
            int[] copyArray = ArrayTestHelper.copyArray(array);
            long t1 = System.nanoTime();
            sort.sort(copyArray);
            long t2 = System.nanoTime();
            double timeInSeconds = (t2 - t1) / Math.pow(10, 9);
            System.out.println("Algorithm " + sort + ", using " + timeInSeconds + " seconds");
        }
    }
}

 

測試結果：

 

 從測試結果中，我們可以發現：

• 取原來的主元，和用隨機數做主元，對於性能的影響完全是隨機的。
• 取中位數做主元，對於性能有着比較明顯的提高。
• 增加閾值，對於性能也有提高，但是閾值選取的數值，還有待深一步的研究。
• 三路快排，在數組區間較小的情況，對於性能的影響是顯著的，但是數組區間較大時，對於性能有一定的影響。
• 遞歸轉迭代的方式，能規避StackOverFlow的情況。

 

但是還有幾個比較奇怪的現象：

• 快速排序，對於數組內部有很多數字相等的情況，處理情況不佳。
• 快慢指針的方式，對於數字相等的情況，效率降低明顯。
• 挖坑填數的方式，比快慢指針的方式，更容易出現StackOverFlow的情況，而快慢指針似乎通過了某種時間為代價的方式，規避了這種情況。

 

希望有讀者能夠解惑這些現象。