快速排序是對冒泡排序的一種改進。它的基本思想是：通過一躺排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一不部分的所有數據都要小，然後再按次方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。最壞情況的時間複雜度爲O(n2)，最好情況時間複雜度爲O(nlog2n)。
假設要排序的數組是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；
例如：待排序的數組A的值分別是：（初始關鍵數據X：=49）
A[1] A[2] A[3] A[4] A[5] A[6] A[7]：
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}
分別對前後兩部分進行快速排序 {13} 27 {38}
結束 結束 {49 65} 76 {97}
49 {65} 結束
結束
圖6 快速排序全過程
1）、設有N（假設N=10）個數，存放在S數組中；
2）、在S[1。。N]中任取一個元素作爲比較基準，例如取T=S[1]，起目的就是在定出T應在排序結果中的位置K，這個K的位置在：S[1。。K-1]<=S[K]<=S[K+1..N]，即在S[K]以前的數都小於S[K]，在S[K]以後的數都大於S[K]；
3）、利用分治思想（即大化小的策略）可進一步對S[1。。K-1]和S[K+1。。N]兩組數據再進行快速排序直到分組對象只有一個數據爲止。
如具體數據如下，那麼第一躺快速排序的過程是：
數組下標： 1 2 3 4 5 6 7 8 9 10
45 36 18 53 72 30 48 93 15 36
I J
（1） 36 36 18 53 72 30 48 93 15 45
（2） 36 36 18 45 72 30 48 93 15 53
（3） 36 36 18 15 72 30 48 93 45 53
（4） 36 36 18 15 45 30 48 93 72 53
（5） 36 36 18 15 30 45 48 93 72 53
通過一躺排序將45放到應該放的位置K，這裏K=6，那麼再對S[1。。5]和S[6。。10]分別進行快速排序。
public class SortQuite{
public static void main(String args []){
int [] arr = {49,38,65,97,76,13,27};
quickSort(arr,0,6);
for(int i = 0;i < arr.length;i++)
System.out.print(" "+arr[i]);
}
/**
* 交換指定數組a的兩個變量的值
* @param a 數組應用
* @param i 數組下標
* @param j 數組下標
*/
public static void swap(int a[], int i, int j) {
if(i == j) return;
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
/**
*
* @param array 待排序數組
* @param low 數組下標下界
* @param high 數組下標上界
* @return pivot
*/
public static int partition(int array[], int low, int high) {
//當前位置爲第一個元素所在位置
int p_pos = low;
//採用第一個元素爲軸
int pivot = array[p_pos];
for (int i = low + 1; i <= high; i++) {
if (array[i] < pivot) {
p_pos++;
swap(array, p_pos, i);
}
}
swap(array, low, p_pos);
return p_pos;
}
/**
* 快速排序實現
* @param array
* @param low
* @param high
*/
public static void quickSort(int array[], int low, int high) {
if (low < high) {
int pivot = partition(array, low, high);
quickSort(array, low, pivot - 1);
quickSort(array, pivot + 1, high);
}
}
}