排序算法中——歸併排序和快速排序

冒泡排序、插入排序、選擇排序這三種算法的時間複雜度都爲 $O(n^2)$，只適合小規模的數據。今天，咱們來認識兩種時間複雜度爲 $O(nlogn)$ 的排序算法——歸併排序（Merge Sort）和快速排序（Quick Sort），他們都用到了 分治思想，很是巧妙。

1. 歸併排序（Merge Sort）？

1.1. 歸併排序算法實現

• 歸併排序的核心思想其實很簡單，若是要排序一個數組，咱們先把數組從中間分紅先後兩部分，而後分別對先後兩部分進行排序，再將排好序的兩部分數據合併在一塊兒就能夠了。

• 歸併排序使用的是分治思想，分治也便是分而治之，將一個大問題分解爲小的子問題來解決。分治算法通常都是用遞歸來實現的。分治是一種解決問題的處理思想，遞歸是一種編程技巧。
• 若是要對數組區間 [p, r] 的數據進行排序，咱們先將數據拆分爲兩部分 [p, q] 和 [q+1, r]，其中 q 爲中間位置。對兩部分數據排好序後，咱們再將兩個子數組合並在一塊兒。當數組的起始位置小於等於終止位置時，說明此時只有一個元素，遞歸也就結束了。

遞推公式：
merge_sort(p…r) = merge(merge_sort(p…q), merge_sort(q+1…r))

終止條件：
p >= r 不用再繼續分解

• 對兩個子數組進行合併的過程以下所示，咱們先創建一個臨時數組，而後從兩個子數組的起始位置開始比較，將較小的元素一個一個放入臨時數組，直到其中一個子數組比較完畢，再將剩下的另外一個子數組餘下的值所有放到臨時數組後面。最後咱們須要將臨時數組中的數據拷貝到原數組對應的位置。

• 代碼實現

// O(n(logn))
void Merge_Sort(float data[], int left, int right, float sorted_data[])
{
    if(left < right)
    {
        int mid = (left + right) / 2;
        Merge_Sort(data, left, mid, sorted_data);
        Merge_Sort(data, mid+1, right, sorted_data);
        Merge_Array(data, left, mid, right, sorted_data);
    }
}

void Merge_Array(float data[], int left, int mid, int right, float temp[])
{
    int i = left, j = mid + 1;
    int k = 0;

    // 從子數組的頭開始比較
    while(i <= mid && j <= right)
    {
        if (data[i] <= data[j])
        {
            temp[k++] = data[i++];
        }
        else
        {
            temp[k++] = data[j++];
        }
    }

    // 判斷哪一個子數組還有元素，並拷貝到 temp 後面
    while(i <= mid)
    {
        temp[k++] = data[i++];
    }
    while(j <= right)
    {
        temp[k++] = data[j++];
    }

    // 將 temp 中的數據拷貝到原數組對應位置
    for(i = 0; i < k; i++)
    {
        data[left+i] = temp[i];
    }
}

1.2. 歸併排序算法分析

• 歸併排序是一個穩定的排序算法，在進行子數組合並的時候，咱們能夠設置當元素大小相等時，先將前半部分的數據放入臨時數組，這樣就能夠保證相等元素在排序後依然保持原來的順序。
• 不只遞歸求解的問題能夠寫成遞推公式，遞歸代碼的時間複雜度也能夠寫成遞歸公式。
• 若是咱們對 $n$ 個元素進行歸併排序所須要的時間是 $T(n)$，那分解成兩個子數組排序的時間都是 $T(\frac{n}{2})$，而合併兩個子數組的時間複雜度爲 $O(n)$。因此，歸併排序的時間複雜度計算公式爲：

$$ T(1) = C $$
$$T(n) = 2*T(\frac{n}{2}) + n, n>1$$

• n = 1 時，只須要常量級的執行時間，因此表示爲 C。

$$T(n) = 2*T(\frac{n}{2}) + n$$
$$ = 2*[2*T(\frac{n}{4}) + \frac{n}{2}] + n = 4*T(\frac{n}{4}) + 2*n $$
$$= 4*[2*T(\frac{n}{8}) + \frac{n}{4}] + 2*n = 8*T(\frac{n}{8}) + 3*n $$
$$......$$
$$= 2^k * T(\frac{n}{2^k}) + k * n$$
$$......$$
當 $\frac{n}{2^k} = 1$時， $k = log_2n$，代入上式得：
$$ T(n) = n * C + nlog_2n$$
用大 O 標記法來表示，歸併排序的時間複雜度爲 $O(nlogn)$。

• 從咱們的分析能夠看出，歸併排序的執行效率與原始數據的有序程度無關，其時間複雜度是很是穩定的，不論是最好狀況、最壞狀況，仍是平均狀況，時間複雜度都是 $O(nlogn)$。
• 歸併排序有一個缺點，那就是它不是原地排序算法。在進行子數組合並的時候，咱們須要臨時申請一個數組來暫時存放排好序的數據。由於這個臨時空間是能夠重複利用的，所以歸併排序的空間複雜度爲 $O(n)$，最多須要存放 $n$ 個數據。

---

2. 快速排序（Quick Sort）？

1.1. 快速排序算法實現

• 快速排序的思想是這樣的，若是要對數組區間 [p, r] 的數據進行排序，咱們先選擇其中任意一個數據做爲 pivot（分支點），通常爲區間最後一個元素。而後遍歷數組，將小於 pivot 的數據放到左邊，將大於 pivot 的數據放到右邊。接着，咱們再遞歸對左右兩邊的數據進行排序，直到區間縮小爲 1 ，說明全部的數據都排好了序。

遞推公式：
quick_sort(p…r) = quick_sort(p…q-1) + quick_sort(q+1, r)

終止條件：
p >= r

• 歸併排序是由下向上的，先處理子數組而後再合併。而快速排序正好相反，它的過程是由上向下的，先分出兩個子區間，再對子區間進行排序。歸併排序是穩定的時間複雜度爲 $O(n)$，但它是非原地算法，而快排則是原地排序算法。

• 快速排序的分區過程以下所示，從左到右依次遍歷數組，如遇到小於 pivot 的元素，則進行數據交換 ，不然繼續往前進行，最後再放置 pivot。

• 代碼實現

// O(n(logn))
void Quick_Sort(float data[], int left, int right)
{
    if (left < right)
    {
        int i = left, j = left;
        int pivot = data[right];

        for (j = left; j < right; j++)
        {
            if (data[j] < pivot)
            {
                int temp = data[i];
                data[i] = data[j];
                data[j] = temp;
                i++;
            }
        }

        data[j] = data[i];
        data[i] = pivot;
        Quick_Sort(data, left, i-1);
        Quick_Sort(data, i+1, right);
    }
}

• 快速排序的另外一種實現方式以下所示，先取出一個元素做爲 pivot（假設是最後一個），這時 pivot 位置能夠看做爲空，而後從左到右查找第一個比 pivot 大的元素放在 pivot 的位置，此時空的地方變成了這第一個比 pivot 大的元素位置。而後從右到左查找第一個比 pivot 小的元素放在剛纔空的位置，依次循環直到從左到右和從右到左都查找到了同一位置，這時候再把 pivot 放置在最後一個空位。這個過程能夠形象的被稱爲「挖坑填坑」。

• 代碼實現

// O(n(logn))
void Quick_Sort(float data[], int left, int right)
{
    if (left < right)
    {
        int i = left, j = right;
        int pivot = data[i];
        while(i < j)
        {
            while(i < j && data[i] <= pivot) // 從左往右找到第一個比 pivot 大的數
            {
                i++;
            }
            if(i < j)
            {
                data[j--] = data[i];
            }
            while(i < j && data[j] >= pivot) // 從右往左找到第一個比 pivot 小的數
            {
                j--;
            }
            if(i < j)
            {
                data[i++] = data[j];
            }
        }
        data[i] = pivot; // i=j
        Quick_Sort(data, left, i-1);
        Quick_Sort(data, i+1, right);
    }
}

2.2. 快速排序算法分析

• 若是快速排序每次都將數據分紅相等的兩部分，則快排的時間複雜度和歸併排序相同，也是 $O(nlogn)$，但這種狀況是很難實現的。若是數據原來已是有序的，則每次的分區都是不均等的，咱們須要進行 n 次分區才能完成整個排序，此時快排的時間複雜度就退化成了 $O(n^2)$。
• 平均時間複雜度的求解也能夠經過遞歸樹來分析，這個問題留待咱們之後再解決。咱們如今只須要知道，在大部分狀況下，快速排序的時間複雜度均可以作到 $O(nlogn)$，只有在極端狀況下，纔會退化成 $O(n^2)$。
• 快速排序是一個原地排序算法，是一個不穩定的排序算法，由於其在數據交換過程當中可能會改變相等元素的原始位置。

---

3. 小結

• 歸併排序和快速排序都是利用分治的思想，代碼都經過遞歸來實現，過程很是類似。
• 歸併排序很是穩定，時間複雜度始終都是 $O(nlogn)$，但不是原地排序；快速排序雖然最壞狀況下時間複雜度爲 $O(n^2)$，但平均狀況下時間複雜度爲 $O(nlogn)$，最壞狀況發生的機率也比較小，並且是原地排序算法，所以應用得更加普遍。

---

參考資料-極客時間專欄《數據結構與算法之美》

獲取更多精彩，請關注「seniusen」!