程式猿修仙之路--演算法之快速排序到底有多快

架構師修行之路發表於2019-04-27
演算法排序
程式猿修仙之路--演算法之快速排序到底有多快

分治思想

關於排序，江湖盛傳有一種分治思想,能大幅度提高排序心法的效能。所謂分治，即：化大為小，分而治之。達到治小而治大的成效。多年來基於分治思想衍生出多種排序心法，然萬變不離其宗！

雖然江湖上演算法內功繁多，但是好的演算法小編認為必須符合以下幾個條件，方能真正提高習練者實力。

  • 時間複雜度（執行時間）

在演算法時間複雜度維度，我們主要對比較和交換的次數做對比，其他不交換元素的演算法，主要會以訪問陣列的次數的維度做對比。

其實有很多修煉者對於演算法的時間複雜度有點模糊，分不清什麼所謂的 O(n),O(nlogn),O(logn)...等，也許下圖對一些人有一些更直觀的認識。

image

  • 空間複雜度（額外的記憶體使用）

排序演算法的額外記憶體開銷和執行時間同等重要。 就算一個演算法時間複雜度比較優秀，空間複雜度非常差，使用的額外記憶體非常大，菜菜認為它也算不上一個優秀的演算法。

  • 結果的正確性

這個指標是菜菜自己加上的，我始終認為一個優秀的演算法最終得到的結果必須是正確的。就算一個演算法擁有非常優秀的時間和空間複雜度，但是結果不正確，導致修煉者經脈逆轉，走火入魔，又有什麼意義呢？

原理

基本思想：選取一個元素作為分割點，通過遍歷把小於分割點的元素放到分割點左邊，把大於分割點的元素放到分割點元素右邊。然後再按此方法對兩部分資料分別排序，以此類推，直到分割的陣列大小為1。 整個排序過程可以遞迴進行，以此達到整個資料變成有序序列。

過程

實現快速排序的方式有很多，其中以類似指標移動方式最為常見，為什麼最常見呢？因為它的空間複雜度為O（1），也就是說是原地排序。

  1. 我們從待排序的記錄序列中選取一個記錄(通常第一個)作為基準元素(稱為key)key=arr[left]，然後設定兩個變數，left指向數列的最左部，right指向資料的最右部。
    image
  2. key首先與arr[right]進行比較，如果arr[right]<key，則arr[left]=arr[right]將這個比key小的數放到左邊去，如果arr[right]>key則我們只需要將right--，right--之後，再拿arr[right]與key進行比較，直到arr[right]<key交換元素為止。
    image
  3. 如果右邊存在arr[right]<key的情況，將arr[left]=arr[right]，接下來，將轉向left端，拿arr[left ]與key進行比較，如果arr[left]>key,則將arr[right]=arr[left]，如果arr[left]<key，則只需要將left++,然後再進行arr[left]與key的比較。
    image
  4. 然後再移動right重複上述步驟
    image
  5. 最後得到 {23 58 13 10 57 62} 65 {106 78 95 85}，再對左子數列與右子數列進行同樣的操作。最終得到一個有序的數列。
{23 58 13 10 57 62} 65 {106 78   95 85}
{10 13} 23 {58 57 62} 65 {85 78 95} 106
10 13 23 57 58 62 65 78 85 95 106
複製程式碼

效能特點

關於複雜度相關O（n）等公式，我這裡需要強調一點,公式代表的是演算法的複雜度增長的趨勢，而不是具體計算複雜度的公式。比如：O（n²）和O（n）相比較，只是說明 O(n²)增長的趨勢要比o(n)快，並不是說明O(n²)的演算法比O(n)的演算法所用時間一定就要多。

時間複雜度

快速排序平均時間複雜度為O(nlogn),最好情況下為O(nlogn)，最壞情況下O(n²)

空間複雜度

基於以上例子來實現的快排，空間複雜度為O(1),也就是原地排序。

穩定性

舉個例子： 待排序陣列:int a[] ={1, 2, 2, 3, 4, 5, 6};

在快速排序的隨機選擇比較子(即pivot)階段： 若選擇a[2]（即陣列中的第二個2）為比較子，，而把大於等於比較子的數均放置在大數陣列中，則a[1]（即陣列中的第一個2）會到pivot的右邊， 那麼陣列中的兩個2非原序（這就是“不穩定”）。 若選擇a[1]為比較子，而把小於等於比較子的數均放置在小數陣列中，則陣列中的兩個2順序也非原序。可見快速排序不是穩定的排序。

改進

通過以上分析各位俠士是否能夠分析出來快速排序有哪些地方存在瑕疵呢？

  1. 切分不平衡：也就是說我們選取的切分元素距離陣列中間值的元素位置很遠，極端情況下會是陣列最大或最小的元素，這就導致了劃分出來的大陣列會被劃分為很多次。針對此情況，我們可以取陣列多個元素來平衡這種情況，例如：我們可以隨機選取三個或者五個元素，取其中間值的元素作為分割元素。
  2. 小陣列：當快速排序切分為比較小的陣列時候，也會利用遞迴呼叫自己。在這種小陣列的情況下，其實一些基礎排序演算法反而比快速排序要快。當陣列比較小的時候不妨嘗試一下切換到插入排序。具體多小是小呢？一般5-15吧，僅供參考。
  3. 重複元素：在我們實際應用中經常會遇到重複元素比較多的情況，按照快排的思想，相同元素是會被頻繁移動和劃分的，其實這完全沒有必要。我們該怎麼辦呢？我們可以把陣列切換為三部分：大於-等於-小於 三部分陣列，這樣等於的那部分陣列就可以避免移動了，不過落地的程式碼複雜度要高很多，有興趣的同學可以實現一下。

使用場景

  1. 當一個陣列大小為中型以上的數量級時，菜菜認為可以使用快速排序，並且伴隨著陣列的持續增大，快速排序的效能趨於平均執行時間。至於多大的陣列為中型，一般認為50+ 吧，僅供參考。
  2. 當一個陣列為無序並且重複元素不多時候，也適合快速排序。為什麼提出重複元素這個點呢？因為如果重複元素過多，本來重複元素是無需排序的，但是快速排序還是要劃分為更多的子陣列來比較，這個時候也許插入排序更適合。

試煉一發吧

c# 武器版
        static void Main(string[] args)
        {
            List<int> data = new List<int>();
            for (int i = 0; i < 11; i++)
            {

                data.Add(new Random(Guid.NewGuid().GetHashCode()).Next(1, 100));
            }
            //列印原始陣列值
            Console.WriteLine($"原始資料： {string.Join(",", data)}");
            quickSort(data, 0, data.Count - 1);
            //列印排序後的陣列
            Console.WriteLine($"排序資料： {string.Join(",", data)}");
            Console.Read();
        }
        public static void quickSort(List <int> source, int left, int right)
        {
            int pivot = 0;
            if (left < right)
            {
                pivot = partition(source, left, right);
                quickSort(source, left, pivot - 1);
                quickSort(source, pivot + 1, right);
            }
        }
        //對一個陣列/列表按照第一個元素 分組排序，返回排序之後key所在的位置索引
        private static int partition(List<int> source, int left, int right)
        {
            int key = source[left];
            while (left < right)
            {
                //從右邊篩選 大於選取的值的不動，小於key的交換位置
                while (left < right && source[right] >= key)
                {
                    right--;
                }
                source[left] = source[right];
                while (left < right && source[left] <= key)
                {
                    left++;
                }
                source[right] = source[left];
            }
            source[left] = key;
            return left;
        }
複製程式碼
golang 武器版
package main

import (
	"fmt"
	"math/rand"
)

func main() {
	var data []int
	for i := 0; i < 10; i++ {
		data = append(data, rand.Intn(100))
	}
	fmt.Println(data)
	quickSort(data[:], 0, len(data)-1)
	fmt.Println(data)
}
func quickSort(source []int, left int, right int) {
	var pivot = 0
	if left < right {
		pivot = partition(source, left, right)                                        
		quickSort(source, left, pivot-1)
		quickSort(source, pivot+1, right)
	}
}

func partition(source []int, left int, right int) int {
	var key = source[left]
	for left < right {
		for left < right && source[right] >= key {
			right--
		}
		source[left] = source[right]
		for left < right && source[left] <= key {
			left++
		}
		source[right] = source[left]
	}
	source[left] = key
	return left
}

複製程式碼

執行結果：

[81 87 47 59 81 18 25 40 56 0]
[0 18 25 40 47 56 59 81 81 87]
複製程式碼

新增關注，檢視更精美版本，收穫更多精彩

image

相關文章