一、快速排序的思想

　　基於分治的思想，是冒泡排序的改進型。首先在數組中選擇一個基準點（該基準點的選取可能影響快速排序的效率，後面講解選取的方法），然後分別從數組的兩端掃描數組，設兩個指示標誌（lo指向起始位置，hi指向末尾)，首先從後半部分開始，如果發現有元素比該基準點的值小，就交換lo和hi位置的值，然後從前半部分開始掃秒，發現有元素大於基準點的值，就交換lo和hi位置的值，如此往復循環，直到lo>=hi,然後把基準點的值放到hi這個位置。一次排序就完成了。以後采用遞歸的方式分別對前半部分和後半部分排序，當前半部分和後半部分均有序時該數組就自然有序了。

排序過程：

二、下面我們來看一個具體的例子：

下面我們通過一個案例來演示一下快速排序的基本步驟： 以序列 46 30 82 90 56 17 95 15 共8個元素

　　　　初始狀態： 46 30 82 90 56 17 95 15 選擇46 作為基準值，i = 0， j = 7

　　　　　　　　　　　i = 0 j = 7

　　　　　　 15 30 82 90 56 17 95 46 15 < 46， 交換 15 和 46，移動 i， i = 1

　　　　　　　　　　　　　i = 1 j = 7

　　　　　　　　　　 15 30 82 90 56 17 95 46 30 < 46， 不需要交換，移動 i ， i = 2

　　　　　　　　　　　　　　　i = 2 j = 7

　　　　　　　　　　 15 30 46 90 56 17 95 82 82 > 46， 交換82 和 46，移動 j ， j = 6

　　　　　　　　　　　　　　　i = 2 j = 6

　　　　　　　　　　 15 30 46 90 56 17 95 82 95 > 46， 不需要交換，移動 j ， j = 5

　　　　　　　　　　　　　　　i = 2 j = 5

　　　　　　　　　　 15 30 17 90 56 46 95 82 17 < 46， 交換46 和 17，移動 i， i = 3

　　　　　　　　　　　　　　　　　i = 3 j = 5

　　　　　　　　　　 15 30 17 46 56 90 95 82 90 > 46， 交換90 和 46，移動 j ， j = 4

　　　　　　　　　　　　　　　3 = i j = 4

　　　　　　　　　　 15 30 17 46 56 90 95 82 56 > 46， 不需要交換，移動 j ， j = 3

　　　　　　　　　　　　　　　 i = j = 3

　　　　i = j = 3， 這樣序列就這樣分割成了兩部分，左邊部分{15， 30， 17} 均小於 基準值（46）；右邊部分 {56， 90，95，82}，均大於基準值。這樣子我們就達到了分割序列的目標。在接著對子序列用同樣的辦法進行分割，直至子序列不超過一個元素，那麽排序結束，整個序列處於有序狀態。

三、快速排序算法的實現：

public static int getMiddle(int[] list, int low, int high){
	int tmp = list[low];//數組的第一個作為中軸
	while (low < high){
		while (low < high && list[high] >= tmp){
			high--;
		}
		list[low] = list[high];//比中軸小的記錄移到低端
		while (low < high && list[low] <= tmp){
			low++;
			}
		list[high] = list[low];//比中軸大的記錄移到高端
		}
	list[low] = tmp;//中軸記錄到尾
	return low;//返回中軸的位置
	}
public static void _quickSort(int[] list, int low, int high){
	if (low < high){
		int middle = getMiddle(list, low, high);//將list數組進行一分為二
		_quickSort(list, low, middle - 1);//對低字表進行遞歸排序
		_quickSort(list, middle + 1, high);//對高字表進行遞歸排序
	}
}

　　所謂的中軸的位置就是選擇的那個基準數所在的位置。

使用的時候直接調用_quickSort方法即可，low為數組的第一個元素的下標0，high為數組的最後一個元素的下標a.length-1。

快速排序的時間復雜度為O(NlogN)。

Java實現快速排序