【漫畫】不要再問我快速排序了

一禪：歸併排序是一種基於分治思想的排序，處理的時候可以採取遞迴的方式來處理子問題。我弄個例子吧，好理解點。例如對於這個陣列arr[] = { 4，1，3，2，7，5，8，0}。

我們把它切割成兩部分。

把左半部分和右半部分分別排序好。

之後再用一個臨時陣列，把這兩個有序的子陣列彙總成一個有序的大陣列

排好之後在複製回源arr陣列

這時，源陣列就排序完畢了

一禪：左半部分和右半部分的排序相當於一個原問題的一個子問題的，也是採取同樣的方式，把左半部分分成兩部分，然後....

直到分割子陣列只有一個元素或0個元素時，這時子陣列就是有序的了(因為只有一個元素或0個，肯定是有序的啊)，就不用再分割了，直接返回就可以了(當然，我在講解這個歸併排序的過程中，是假設你大致瞭解歸併排序的前提下的了)

一禪：把一個n個元素的陣列分割成只有一個元素的陣列，那麼我需要切logn次，每次把兩個有序的子陣列彙總成一個大的有序陣列，所需的時間複雜度為O(n)。所以總的時間複雜度為O(nlogn)

快速排序

小白：那倒不是，快速排序的平均時間複雜度也是O(nlogn)，不過他不需要像歸併排序那樣，還需要一個臨時的陣列來輔助排序，這可以節省掉一些空間的消耗，而且他不像歸併排序那樣，把兩部分有序子陣列彙總到臨時陣列之後，還得在複製回源陣列，這也可以節省掉很多時間。

小白：快速排序也是和歸併排序差不多，基於分治的思想以及採取遞迴的方式來處理子問題。例如對於一個待排序的源陣列arr = { 4，1，3，2，7，6，8}。

我們可以隨便選一個元素，假如我們選陣列的第一個元素吧，我們把這個元素稱之為”主元“吧。

然後將大於或等於主元的元素放在右邊，把小於或等於主元的元素放在左邊。

透過這種規則的調整之後，左邊的元素都小於或等於主元，右邊的元素都大於或等於主元，很顯然，此時主元所處的位置，是一個有序的位置,即主元已經處於排好序的位置了。

主元把陣列分成了兩半部分。把一個大的陣列透過主元分割成兩小部分的這個操作，我們也稱之為分割操作(partition)。

接下來，我們透過遞迴的方式，對左右兩部分採取同樣的方式，每次選取一個主元 元素，使他處於有序的位置。

那什麼時候遞迴結束呢？當然是遞迴到子陣列只有一個元素或者0個元素了

分割操作：單向調整

一禪：就按照你說的，選一個主元，你剛才選的是第一個元素為主元，這次我選最後一個為主元吧，哈哈。假設陣列arr的範圍為[left, right]，即起始下標為left，末尾下標為right。源陣列如下

然後可以用一個下標 i 指向 left，即 i = left ;用一個下標 j 也指向l eft，即j = left 

接下來 j 從左向右遍歷，遍歷的範圍為 [left, right-1] ，遍歷的過程中，如果遇到比主元小的元素，則把該元素與 i 指向的元素交換，並且 i = i +1

當j指向1時，1比4小，此時把i和j指向的元素交換，之後 i++。

就這樣讓j一直向右遍歷，直到 j = right

遍歷完成之後，把 i 指向的元素與主元進行交換，交換之後，i 左邊的元素一定小於主元，而 i 右邊的元素一定大於或等於主元。這樣，就 i 完成了一次分割了。

一禪一言不合就把程式碼擼好了，第一版程式碼如下：

//分割操作：方法一，單向調整
int partion(int a[], int left, int right)
{
    int temp,pivot;//pivot存放主元
    int i,j;
    i = left;
    pivot = a[right];
    for(j = left;j < right;j++)
    {
        if(a[j] < pivot)
        {  //交換值
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
            i++;
        }
    }
    a[right] = a[i];
    a[i] = pivot;
    return i;//把主元的下標返回
}
//快速排序
void QuickSort(int a[], int left, int right)
{
    int center;
    int i,j;
    int temp;
    if(left < right)
    {
       center = partion(a,left,right);
       QuickSort(a,left,center-1);//左半部分
       QuickSort(a,center+1,right);//右半部分
    }
}

分割操作：雙向調整

小白：對啊，因為你這調整方法，可能會出現對同一個元素，進行多次交換，例如剛才你在演示的那組元素，在j向右遍歷交換的過程中：

第一次：8和1交換

第二次：8和3交換

第三次：8和2交換

8被重複交換了很多次

小白：其實，我們可以這樣來調整元素。我還是用我的第一個元素充當主元吧。哈哈

源陣列如下

然後用令變數i = left + 1，j = right。然後讓 i 和 j 從陣列的兩邊向中間掃描。

i 向右遍歷的過程中，如果遇到大於或等於主元的元素時，則停止移動，j向左遍歷的過程中，如果遇到小於或等於主元的元素則停止移動。

當i和j都停止移動時，如果這時i < j，則交換 i, j 所指向的元素。此時 i < j，交換8和3

然後繼續向中間遍歷，直到i >= j。

此時i >= j，分割結束。

最後在把主元與 j 指向的元素交換(當然，與i指向的交換也行)。

這個時候，j 左邊的元素一定小於或等於主元，而右邊則大於或等於主元。

到此，分割調整完畢

程式碼如下：

方法二：雙向掃描
int partition2( int[] arr, int left, int right)
{
  int pivot = arr[left];
  int i = left + 1;
  int j = right;
  while(true)
  {  
    //向右遍歷掃描
    while(i < j && arr[i] <= pivot) i++;
    //向左遍歷掃描
    while(i < j && arr[j] => pivot) j--;
    if(i >= j)
      break;
    //交換
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  }
  //把arr[j]和主元交換
  arr[left] = arr[j];
  arr[j] = povit;
  return j;
}

時間複雜度

小白：因為快速排序的最壞時間複雜度是O(n2)。

例如有可能會出現一種極端的情況，每次分割的時候，主元左邊的元素個數都為0，而右邊都為n-1個。這個時候，就需要分割n次了。而每次分割整理的時間複雜度為O(n)，所以最壞的時間複雜度為O(n2)。

而最好的情況就是每次分割都能夠從陣列的中間分割了，這樣分割logn次就行了，此時的時間複雜度為O(nlogn)。

而平均時間複雜度，則是假設每次主元等機率著落在陣列的任意位置，最後算出來的時間複雜度為O(nlogn)，至於具體的計算過程，我就不展開了。

不過顯然，像那種極端的情況是極少發生的。

小白：哈哈，之所以說它快，是因為它不像歸併排序那樣，需要額外的輔助空間，而且在分割調整的時候，不像歸併排序那樣，元素還要在輔助陣列與源陣列之間來回複製。

穩定性

一禪：不是啊，例如，在排序的過程中，主元在和j交換的時候是有可能破壞穩定性的，例如

把主元與j指向的元素進行交換

本次算是講到這裡結束了，不過我這裡再提供另一種隨機選取主元的方法，為了降低極端情況出現的可能性，我們可以隨機選取主元，而不是固定一個位置選取。程式碼去下：

//隨機選取主元
int random_partition(int[] arr, int left, int right)
{
  i = random(left, right);//隨機選取一個位置
  //在把這個位置的元素與ar[left]交換
  swap(arr[i], arr[left]);
  
  return partition(arr, left, right);
}

終於寫完，這個快排寫了挺長時間，覺得有收穫的話，可以轉發支援一波哦(´-ω-`)。

原文連結：https://mp.weixin.qq.com/s/N9dGTUWip-sLJzH3HMb8Aw