A. 快速排序的原理是什麼
先
數據序列
選
元素,並
序列
所
比該元素
元素都放
右邊或左邊,再
左右兩邊
別用同
處
直
每
待處理
序列
度
1,
處理結束
前
序區R[1..H]
任取
數據元素作
比較
"基準"(
妨記
X)
用
基準
前
序區劃
左右兩
較
序區：R[1..I-1]
R[I+1..H]
且左邊
序
區
數據元素均
於等於基準元素
右邊
序
區
數據元素均
於等於基準元素
基準X則位於
終排序
位置
即R[1..I-1]≤X.Key≤R[I+1..H](1≤I≤H)
R[1..I-1]
R[I+1..H]均非空
別
進行
述
劃
程
直至所
序
區
數據元素均已排序
止
快速排序
基本思想
基於
治策略
於輸入
序列L[p..r]
規模足夠
則直接進行排序（比
用前述
冒泡、選擇、插入排序均
）
否則
三步處理：
解(Divide)：
待排序列L[p..r]劃
兩
非空
序列L[p..q]
L[q+1..r]
使L[p..q]
任
元素
值
於L[q+1..r]
任
元素
值
具體
通
途徑實現：
序列L[p..r]
選擇數據元素L[q]
經比較
移
L[q]
處於L[p..r]
間
適
位置
使
數據元素L[q]
值
於L[q+1..r]
任
元素
值
遞歸求解(Conquer)：通
遞歸調用快速排序算
別
L[p..q]
L[q+1..r]進行排序
合並(Merge)：由於
解
兩
序列
排序
進行
所
L[p..q]
L[q+1..r]都排
序
需要執行任何計算L[p..r]
已排
序
即自
合並
解決流程
符合
治
基本步驟
快速排序
治
經典應用實例
B. 如何理解快速排序演算法的思想
#include <iostream>
using std::cout;
using std::endl;
int Partition( int *R, int low, int high){
// 對記錄子序列 R[low..high] 進行一趟快速排序，並返回樞軸記錄
// 所在位置，使得在它之前的記錄的關鍵字均不大於它的關鍵字，
// 而在它之後的記錄的關鍵字均不小於它的關鍵字
R[0] = R[low]; // 將樞軸記錄移至數組的閑置分量
int pivotkey = R[low]; // 樞軸記錄關鍵字
cout << endl << "pivotkey : " << pivotkey << endl;
while(low < high){ // 從表的兩端交替地向中間掃描
while( low<high && R[high]>=pivotkey ){
--high;
}
if(low < high){//需要進行這樣的判斷，如果是由於low>=high而退出的循環，不需要移動數據
R[low++] = R[high]; // 將比樞軸記錄小的記錄移到低端
//cout << "移動的hign數據：" << R[high] << endl;
}
while (low<high && R[low]<=pivotkey )
++low;
if(low < high){
R[high--] = R[low]; // 將比樞軸記錄大的記錄移到高端
//cout << "移動的low數據：" << R[low] << endl;
}
} // while
R[low] = R[0]; // 樞軸記錄移到正確位置
//cout << "返回的pivotkey: " << low << endl;
for(int i = 1; i<=10; i++){
cout << R[i-1] << " ";
}
return low; // 返回樞軸位置
} // Partition
void QSort(int *R, int s, int t ){
// 對記錄序列 R[s..t] 進行快速排序
if (s < t){ // 長度大於1
int pivotloc = Partition(R, s, t);// 對 R[s..t] 進行一趟快排，並返回樞軸位置
QSort(R, s, pivotloc-1);//對低子序列遞歸進行排序
QSort(R, pivotloc+1, t);//對高子序列遞歸進行排序
}//if
}//Qsort
int main(){
int li[10] = {0,38,65,97,76,13,27,48,55,4};
cout<<"注意:R[0]為數組的閑置分量"<<endl;
for(int i = 1; i<=10; i++){
cout << li[i-1] << " ";
}
cout << endl;
QSort(li,1,9);
cout << endl;
for(int i = 1; i<=10; i++){
cout << li[i-1] << " ";
}
cout << endl;
return 0;
}
C. 快速排序方法的簡單解釋
快排的思想是（假設都是從小到大排列）：
選一個值作為「軸值」，所有小於軸值的都移動到軸值左邊，所有大於軸值的都移動到軸值右邊。這一步是讓數列變得較為有序
然後分別再對軸值的左邊、右邊分別進行快排，一步一步提高整個數列的有序程度，直到最後完全有序。
軸值的選取有多種方式，這里就假設是選正中間的一個
70，75，82，90，23，16，10，68
選擇軸值 90，排列後得到：
70，75，82，23，16，10，68，(90)
括弧括起來的我表示是軸值，這里運氣不好，軸值選中了一個最大的
下面對軸值左邊排序，在選擇軸值為23：
16，10，(23)，70，75，82，68
再分別對16， 10 和 70，75，82，68進行排序
一般快排在待排序的數字個數較少時，會選取其它排序來進行排列，比如插入排序。這里16，10數字個數已經太少，用插入排序排成10， 16
然後對 70，75，82，68進行排序……
整個排序過程就這樣
D. 簡單介紹一下快速排序的思想
基本思想快速排序（Quicksort）是對冒泡排序的一種改進。由C. A. R. Hoare在1962年提出。它的基本思想是：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。 快排 演算法過程設要排序的數組是A[0]……A[N-1]，首先任意選取一個數據（通常選用第一個數據）作為關鍵數據，然後將所有比它小的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一趟快速排序。一趟快速排序的演算法是：
1）設置兩個變數I、J，排序開始的時候：I=1，J=N-1；
2）以第一個數組元素作為關鍵數據，賦值給X，即 X=A[0]；
3）從J開始向前搜索，即由後開始向前搜索（J=J-1），找到第一個小於X的值，讓該值與X交換；
4）從I開始向後搜索，即由前開始向後搜索（I=I+1），找到第一個大於X的值，讓該值與X交換；
5）重復第3、4步，直到 I=J；
例如：待排序的數組A的值分別是：（初始關鍵數據：X=49）
A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]：
49 38 65 97 76 13 27
進行第一次交換後： 27 38 65 97 76 13 49
( 按照演算法的第三步從後面開始找)
進行第二次交換後： 27 38 49 97 76 13 65
( 按照演算法的第四步從前面開始找>X的值，65>49,兩者交換，此時：I=3 )
進行第三次交換後： 27 38 13 97 76 49 65
( 按照演算法的第五步將又一次執行演算法的第三步從後開始找
進行第四次交換後： 27 38 13 49 76 97 65
( 按照演算法的第四步從前面開始找大於X的值，97>49,兩者交換，此時：J=4 )
此時再執行第三步的時候就發現I=J，從而結束一躺快速排序，那麼經過一趟快速排序之後的結果是：27 38 13 49 76 97 65，即所以大於49的數全部在49的後面，所以小於49的數全部在49的前面。
快速排序就是遞歸調用此過程——在以49為中點分割這個數據序列，分別對前面一部分和後面一部分進行類似的快速排序，從而完成全部數據序列的快速排序，最後把此數據序列變成一個有序的序列，根據這種思想對於上述數組A的快速排序的全過程如圖6所示：
初始狀態 {49 38 65 97 76 13 27}
進行一次快速排序之後劃分為 {27 38 13} 49 {76 97 65}
分別對前後兩部分進行快速排序 {27 38 13} 經第三步和第四步交換後變成 {13 27 38} 完成排序。
{76 97 65} 經第三步和第四步交換後變成 {65 76 97} 完成排序。
變種演算法快速排序(Quicksort)有三個值得一提的變種演算法，這里進行一些簡要介紹：
平衡快排（Balanced Quicksort）: 每次盡可能地選擇一個能夠代表中值的元素作為關鍵數據，然後遵循普通快排的原則進行比較、替換和遞歸。
外部快排（External Quicksort）: 與普通快排不同的是，關鍵數據是一段buffer，首先將之前和之後的M/2個元素讀入buffer並對該buffer中的這些元素進行排序，然後從被排序數組的開頭（或者結尾）讀入下一個元素，假如這個元素小於buffer中最小的元素，把它寫到最開頭的空位上；假如這個元素大於buffer中最大的元素，則寫到最後的空位上；否則把buffer中最大或者最小的元素寫入數組，並把這個元素放在buffer里。保持最大值低於這些關鍵數據，最小值高於這些關鍵數據，從而避免對已經有序的中間的數據進行重排。完成後，數組的中間空位必然空出，把這個buffer寫入數組中間空位。然後遞歸地對外部更小的部分，循環地對其他部分進行排序。
三路基數快排（Three-way Radix Quicksort，也稱作Multikey Quicksort、Multi-key Quicksort）: 結合了基數排序（radix sort，如一般的字元串比較排序就是基數排序）和快排的特點，是字元串排序中比較高效的演算法。該演算法被排序數組的元素具有一個特點，即multikey，如一個字元串，每個字母可以看作是一個key。演算法每次在被排序數組中任意選擇一個元素作為關鍵數據，首先僅考慮這個元素的第一個key（字母），然後把其他元素通過key的比較分成小於、等於、大於關鍵數據的三個部分。然後遞歸地基於這一個key位置對「小於」和「大於」部分進行排序，基於下一個key對「等於」部分進行排序。
E. 快速排序演算法（free pascal)詳解，不要源程序，時間復雜度n（logn）；謝了//
快速排序是對冒泡排序的一種改進。它的基本思想是：通過一躺排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一不部分的所有數據都要小，然後再按次方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
假設要排序的數組是A[1]……A[N]，首先任意選取一個數據（通常選用第一個數據）作為關鍵數據，然後將所有比它的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一躺快速排序。一躺快速排序的演算法是：
1）、設置兩個變數I、J，排序開始的時候I：=1，J：=N；
2）以第一個數組元素作為關鍵數據，賦值給X，即X：=A[1]；
3）、從J開始向前搜索，即由後開始向前搜索（J：=J-1），找到第一個小於X的值，兩者交換；
4）、從I開始向後搜索，即由前開始向後搜索（I：=I+1），找到第一個大於X的值，兩者交換；
5）、重復第3、4步，直到I>j；
詳細過程舉例如下：
原序： [26 5 37 1 61 11 59 15 48 19]
一： [19 5 15 1 11] 26 [59 61 48 37]
二： [11 5 15 1] 19 26 [59 61 48 37]
三： [1 5] 11 [15] 19 26 [59 61 48 37]
四： 1 5 11 [15] 19 26 [59 61 48 37]
五： 1 5 11 15 19 26 [59 61 48 37]
六： 1 5 11 15 19 26 [37 48] 59 [61]
七： 1 5 11 15 19 26 37 48 59 [61]
八： 1 5 11 15 19 26 37 48 59 61
快速排序法是所有排序方法中速度最快、效率最高的方法。程序如下：
var a:array[0..10] of integer；
n:integer;
procere qsort(l,r:longint);{r，l表示集合的左右邊界，即把第r到第l個數進行排序}
var i,j,m:longint;
begin
m:=a[l];{標准數}
i:=l; {I，J為指針}
j:=r;
repeat
while a[i]<m do inc(i);
while a[j]>m do dec(j);
if i<=j then begin
a[0]:=a[i];
a[i]:=a[j];
a[j]:=a[0];
inc(i);
dec(j);
end;
until i>j;
if l<j then qsort(l,j); {如果集合中不止一個數則進入下一層遞歸，l，J為新邊界}
if i<rthen qsort(i,r); {如果集合中不止一個數則進入下一層遞歸，i，r為新邊界}
end;
begin
for n:=1 to 10 do read(a[n]);
qsort(1,10);
for n:=1 to 10 do write(a[n]:4);
end.
F. 如何用java實現快速排序，簡答講解下原理
快速排序思想：
通過對數據元素集合Rn 進行一趟排序劃分出獨立的兩個部分。其中一個部分的關鍵字比另一部分的關鍵字小。然後再分別對兩個部分的關鍵字進行一趟排序，直到獨立的元素只有一個，此時整個元素集合有序。
快速排序的過程，對一個元素集合R[ low ... high ] ,首先取一個數（一般是R[low] ）做參照 ， 以R[low]為基準重新排列所有的元素。
所有比R[low]小的放前面，所有比R[low] 大的放後面，然後以R[low]為分界，對R[low ... high] 劃分為兩個子集和，再做劃分。直到low >= high 。
比如：對R={37, 40, 38, 42, 461, 5, 7, 9, 12}進行一趟快速排序的過程如下(注:下面描述的內容中元素下表從 0 開始)：
開始選取基準 base = 37，初始位置下表 low = 0 ， high = 8 ， 從high=8，開始如果R[8] < base , 將high位置中的內容寫入到R[low]中, 將high位置空出來, low = low +1 ;
從low開始探測，由於low=1 ， R[low] > base ,所以將R[low]寫入到R[high] , high = high -1 ;
檢測到low < high ,所以第一趟快速排序仍需繼續:
此時low=1，high=7，因為 R[high] < base ,所以將 R[high] 寫入到到R[low]中,low = low + 1;
從low開始探測,low = 2 , R[low] >base ,所以講R[low]寫入到R[high]，high=high-1;
繼續檢測到 low 小於high
此時low=2，high=6，同理R[high] < base ,將R[high] 寫入到R[low]中，low=low+1;
從low繼續探測,low = 3 , high=6 , R[low] > base , 將R[low]寫入到R[high]中，high = high-1;
繼續探測到low小於high
此時low=3，high=5，同理R[high] < base,將R[high]寫入到R[low]中，low = low +1；
從low繼續探測，low = 4，high=5，由於R[low] > base , 將R[low]寫入到R[high]中，high = high -1 ;
此時探測到low == high == 4 ；該位置即是base所在的位置，將base寫入到該位置中.
然後再對子序列Rs1 = {12,9,7,5} 和 Rs2={461,42,38,40}做一趟快速排序，直到Rsi中只有一個元素，或沒有元素。
快速排序的Java實現：
private static boolean isEmpty(int[] n) {
return n == null || n.length == 0;
}
// ///////////////////////////////////////////////////
/**
* 快速排序演算法思想——挖坑填數方法：
*
* @param n 待排序的數組
*/
public static void quickSort(int[] n) {
if (isEmpty(n))
return;
quickSort(n, 0, n.length - 1);
}
public static void quickSort(int[] n, int l, int h) {
if (isEmpty(n))
return;
if (l < h) {
int pivot = partion(n, l, h);
quickSort(n, l, pivot - 1);
quickSort(n, pivot + 1, h);
}
}
private static int partion(int[] n, int start, int end) {
int tmp = n[start];
while (start < end) {
while (n[end] >= tmp && start < end)
end--;
if (start < end) {
n[start++] = n[end];
}
while (n[start] < tmp && start < end)
start++;
if (start < end) {
n[end--] = n[start];
}
}
n[start] = tmp;
return start;
}
在代碼中有這樣一個函數：
public static void quickSortSwap(int[] n, int l, int h)
該函數可以實現，元素集合中特定的 l 到 h 位置間的數據元素進行排序。
G. 快速排序的原理 詳細點 謝謝
快速排序（Quicksort）是對冒泡排序的一種改進。由C. A. R. Hoare在1962年提出。它的基本思想是：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
一趟快速排序的演算法是：
1）設置兩個變數i、j，排序開始的時候：i=0，j=N-1；
2）以第一個數組元素作為關鍵數據，賦值給key，即key=A[0]；
3）從j開始向前搜索，即由後開始向前搜索(j--)，找到第一個小於key的值A[j]，將值為key的項與A[j]交換；
4）從i開始向後搜索，即由前開始向後搜索(i++)，找到第一個大於key的A[i]，將值為key的項與A[i]交換；
5）重復第3步
6）重復第3、4、5步，直到i=j； (3,4步中，沒找到符合條件的值，即3中A[j]不小於key,4中A[j]不大於key的時候改變j、i的值，使得j=j-1，i=i+1，直至找到為止。找到符合條件的值，進行交換的時候i， j指針位置不變。另外，i==j這一過程一定正好是i+或j-完成的時候，此時令循環結束）。
H. 按鍵精靈快速排序（比冒泡更快更有效率的演算法）是怎麼樣的
冒泡排序為O(N^2)，在排序過程中其實是效率較低的。在掃拍賣或者其他需要比拼速度的時候，時間就是金錢~越快越能搶佔先機。
今天我們介紹另一種更快更有效率的排序——快速排序，時間復雜度為O(n*logn)。
快速排序的演算法思想
快速排序採用了一種分治的策略，通常稱其為分治法(Divide-and-ConquerMethod)。
該方法的基本思想是：
1．先從數列中取出一個數作為基準數。（不要被這個名詞嚇到了，就是一個用來參照的數，待會你就知道它用來做啥的了）。
2．分區過程，將比這個數大的數全放到它的右邊，小於或等於它的數全放到它的左邊。
3 . 再對左右區間重復第二步，直到各區間只有一個數。
白話講解演算法：
假設我們現在對「6 1 2 7 9 3 4 5 10 8」這個10個數進行排序。就讓第一個數6作為基準數吧。接下來，需要將這個序列中所有比基準數大的數放在6的右邊，比基準數小的數放在6的左邊。
方法其實很簡單：分別從初始序列「6 1 2 7 9 3 4 5 10 8」兩端開始「探測」。先從右往左找一個小於6的數，再從左往右找一個大於6的數，然後交換他們。這里可以用兩個變數i和j，分別指向序列最左邊和最右邊。我們為這兩個變數起個好聽的名字「哨兵i」和「哨兵j」。剛開始的時候讓哨兵i指向序列的最左邊（即i=1），指向數字6。讓哨兵j指向序列的最右邊（即=10），指向數字。
2014-8-29 13:45 上傳
下載附件 (9.51 KB)
首先哨兵j開始出動。因為此處設置的基準數是最左邊的數，所以需要讓哨兵j先出動，這一點非常重要（請自己想一想為什麼）。哨兵j一步一步地向左挪動（即j--），直到找到一個小於6的數停下來。接下來哨兵i再一步一步向右挪動（即i++），直到找到一個數大於6的數停下來。最後哨兵j停在了數字5面前，哨兵i停在了數字7面前。
2014-8-29 13:45 上傳
下載附件 (9.74 KB)
2014-8-29 13:45 上傳
下載附件 (8.13 KB)
現在交換哨兵i和哨兵j所指向的元素的值。交換之後的序列如下：
6 1 2 5 9 3 4 7 10 8
2014-8-29 13:45 上傳
下載附件 (9.74 KB)
2014-8-29 13:45 上傳
下載附件 (8.37 KB)
到此，第一次交換結束。接下來開始哨兵j繼續向左挪動（再友情提醒，每次必須是哨兵j先出發）。他發現了4（比基準數6要小，滿足要求）之後停了下來。哨兵i也繼續向右挪動的，他發現了9（比基準數6要大，滿足要求）之後停了下來。此時再次進行交換，交換之後的序列如下：
6 1 2 5 4 3 9 7 10 8
第二次交換結束，「探測」繼續。哨兵j繼續向左挪動，他發現了3（比基準數6要小，滿足要求）之後又停了下來。哨兵i繼續向右移動，糟啦！此時哨兵i和哨兵j相遇了，哨兵i和哨兵j都走到3面前。說明此時「探測」結束。我們將基準數6和3進行交換。交換之後的序列如下：
3 1 2 5 4 6 9 7 10 8
2014-8-29 13:45 上傳
下載附件 (8.28 KB)
2014-8-29 13:45 上傳
下載附件 (10.45 KB)
2014-8-29 13:45 上傳
下載附件 (8.48 KB)
到此第一輪「探測」真正結束。此時以基準數6為分界點，6左邊的數都小於等於6，6右邊的數都大於等於6。回顧一下剛才的過程，其實哨兵j的使命就是要找小於基準數的數，而哨兵i的使命就是要找大於基準數的數，直到i和j碰頭為止。
OK，解釋完畢。現在基準數6已經歸位，它正好處在序列的第6位。
3
1
2
5
4
6
9
7
10
8
此時我們已經將原來的序列，以6為分界點拆分成了兩個序列，左邊的序列是「3 1 2 5 4」，右邊的序列是「9 7 10 8」。接下來還需要分別處理這兩個序列。因為6左邊和右邊的序列目前都還是很混亂的。不過不要緊，我們已經掌握了方法，接下來只要模擬剛才的方法分別處理6左邊和右邊的序列即可。現在先來處理6左邊的序列現吧。
左邊的序列是「3 1 2 5 4」。請將這個序列以3為基準數進行調整，使得3左邊的數都小於等於3，3右邊的數都大於等於3。
3
1
2
5
4
第一次交換完：以3為分界點，拆分了兩個序列。左邊都比3小，右邊都比3大。
2
1
3
5
4
再分別處理3左右的兩個序列「2 1」和「5 4」
1
2
3
4
5
這樣，最初我們劃分的6左側的序列都已經處理好了~~我們再來處理6右側的序列
9
7
10
8
以9為基準數，第一次交換完：
9
7
8
10
第二次交換：
8
7
9
10
再交換一次：
7
8
9
10
這樣，我們整個序列就排序完畢了
1
2
3
4
5
6
7
8
9
10
快排演算法代碼實現：
su = "6|1|2|7|9|3|4|5|10|8"
su=Split(su, "|")
L = UBound(su)
Call ks(0, L)
Function ks(L, B)
If L > B Then
Exit Function
End If //判斷數組上標下標是否超出范圍
i = L
j = B
key =int( su(L) ) //數組第一位提取作為基數
While j>i
While int ( su(j)) >= key and j > i //要先從最右邊開始找 找到第一個小於key的數 這里添加的j>i的判斷是為了防止j的值不斷遞減導致下標越界
j = j - 1
Wend
While int (su(i)) <= key and j > i //從最左邊開始找 找到第一個大於key的數 （這里的字元串數組需要轉換為數值型）
i = i + 1
Wend
If j>i then // 將和基數key對比得到的兩個數對換 將大於key的值往右邊放 小於key的值往左邊放
T = su(i)
su(i) = su(j)
su(j) = T
End If
Wend // 這個 While 循環當i=j 第一輪比較完退出
su(L) = su(i) // 重新設置數組第一個元素為基數
su(i) = key// 基數歸位 （排完一輪之後 左邊的數<基數<右邊的數 那麼基數就到了排序中它該在的位置。）
Call ks(L, i - 1)//繼續處理左邊的數
Call ks(i + 1, B)//繼續處理右邊的數
End Function
For i = 0 To UBound(su)
TracePrint su(i)
Next
I. 快速排序演算法為什麼要雙指針
這是快速排序的思路決定的。快速排序的思想是這樣的：
從數組中選取一個元素作為基準值，將待排序的數組分成左右兩部分，左邊的部分小於基準值，右邊的部分大於基準值。左右兩部分繼續如此遞歸下去，不斷分裂，直到待排序數組的元素為1，此時遞歸條件結束。
所以使用雙指針交替向中間移動，左邊的指針在比基準值大的下標時停下，右邊的指針在比基準小的下標時停下，雙方交換數組元素，繼續向左、向右移動。
這一輪的移動到什麼地方停止呢？那就是在左右指針下標值相等的時候，將這個下標值的元素與基準值元素交換。
一輪下來，這個基準值位置確定，就不會再發生改變了。以它為分界線，分成左右兩部分，剩下的排序它都不用參與了。
分開了左右兩段之後，我們把左右段看成各自獨立的待排序數組就好，做法與上面一致，只不過此時的待排序數組比較短了。使用遞歸實現就非常方便。
在不斷的分裂過後，待排序數組只為一個元素的時候，排序就結束了。
J. 誰能幫我講解一下 作業排序的一個更快演算法的思想～
快速排序是一種分割處理式的排序演算法，它將一個復雜的排序問題分解為若干較容易處理的排序問題，然後逐一解決。在快速排序演算法中，首先要從數據集的數據中選擇一個數據作為分割值，然後將數據分成以下3個子集：
(1) 將大於分割值的數據移到分割值前面，組成子集1；
(2) 分割值本身為子集2；
(3) 將小於分割值的數據移到分割值後面，組成子集3。
等於分割值的數據可以放在任意一個子集中，這對快速排序演算法沒有任何影響。由於子集2已經是有序的，所以此後只需對子集1和子集3進行快速排序。
需要注意的是，當數據集很小時，無法進行快速排序，而要使用其它排序演算法。顯然，當數據集中的數據只有兩個或更少時，就不可能將數據集再分割成三個子集。實際上，當數據集比較小時，程序員就應該考慮是否仍然採用快速排序演算法，因為在這種情況下另外一些排序演算法往往更快。