這篇文章，以對話的方式，詳細着講解了快速排序以及排序排序的一些優化。
一禪：歸併排序是一種基於分治思想的排序，處理的時候可以採取遞歸的方式來處理子問題。我弄個例子吧，好理解點。例如對於這個數組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);
}
終於寫完，這個快排寫了挺長時間，覺得有收穫的話，可以轉發支持一波哦(´-ω-`)。
另外，帥地把公衆號的精華文章整理成了一本電子書，共 630頁！目錄如下
現在免費送給大家，在我的公衆號帥地玩編程回覆程序員內功修煉即可獲取。
兄dei，如果覺得我寫的不錯，不妨幫個忙
1、關注我的原創微信公衆號「帥地玩編程」，每天準時推送乾貨技術文章，專注於寫算法 + 計算機基礎知識（計算機網絡+ 操作系統+數據庫+Linux），聽說關注了的不優秀也會變得優秀哦。
2、給俺點個讚唄，可以讓更多的人看到這篇文章，順便激勵下我，嘻嘻。
作者簡潔
作者：大家好，我是帥地，從大學、自學一路走來，深知算法，計算機基礎知識的重要性，所以申請了一個微星公衆號『帥地玩編程』，專業於寫這些底層知識，提升我們的內功，帥地期待你的關注，和我一起學習。 轉載說明：未獲得授權，禁止轉載