基本思想：

1）選擇一個基準元素,通常選擇第一個元素或者最後一個元素,

2）通過一趟排序講待排序的記錄分割成獨立的兩部分，其中一部分記錄的元素值均比基準元素值小。另一部分記錄的 元素值比基準值大。

3）此時基準元素在其排好序後的正確位置

4）然後分別對這兩部分記錄用同樣的方法繼續進行排序，直到整個序列有序。

快速排序的示例：

（a）一趟排序的過程：

（b）排序的全過程

演算法的實現：

 遞迴實現：

import java.util.Arrays;

public class QuickSort {
	public static void main(String[] args) {
		int[] data = { 5, 1, 9, 3, 7, 4, 8, 6, 2 };
		System.out.println("排序前：" + Arrays.toString(data));
		quickSort(data, 0, data.length - 1);
		System.out.println("排序後：" + Arrays.toString(data));

	}

	private static void quickSort(int[] data, int low, int high) {
		int base;
		if (low < high) {
			base = partition(data, low, high);
			quickSort(data, low, base - 1);
			quickSort(data, base + 1, high);
		}
	}

	private static int partition(int[] data, int i, int j) {
		int base = data[i];// 選定第一個數為基準 (可以優化為三數取中，即取左右中三個數的中間數）

		while (i < j) {
			while (i < j && data[j] > base)
				j--;
			if (i < j) // 如果不加此比較，swap兩個相同位置的記錄，結果是0
				swap(data, i, j); // 將比樞軸記錄小的交換到低端

			while (i < j && data[i] < base)
				i++;
			if (i < j)
				swap(data, i, j); // 將比樞軸記錄大的交換到高階
		}
		return i;
	}

	private static void swap(int[] a, int i, int j) {

		a[i] = a[i] + a[j];
		a[j] = a[i] - a[j];
		a[i] = a[i] - a[j];
	}

	// 優化演算法 優化遞迴操作及小陣列時的排序方案
	private static void quickSort1(int[] data, int low, int high) {
		int base;
		int max_length_insert_sort = 9;// 當high-low大於常數時用快速排序
		if ((high - low) > max_length_insert_sort) {
			while (low < high) {
				base = partition1(data, low, high);
				quickSort1(data, low, base - 1);//對低子表遞迴排序
				low = base + 1;//尾遞迴
			}
		} else
			new StraightInsertionSort().insertionSort2(data);// 否則用插入排序
	}

	// 優化不必要的交換
	private static int partition1(int[] data, int i, int j) {
		int base = data[i];// 選定第一個數為基準
		int temp = base; // 備份樞軸
		while (i < j) {
			while (i < j && data[j] > base)
				j--;
			data[i] = data[j];// 採用替換而不是交換的方式進行操作

			while (i < j && data[i] < base)
				i++;
			data[j] = data[i];// 採用替換而不是交換的方式進行操作
		}
		data[i] = temp;// 將樞軸值替換回來
		return i;
	}

	// 三數取中 :即取三個關鍵字先進行排序，將中間數作為樞軸，一般取左端、右端、中間三個數。
	public int getMiddle(int[] data, int i, int j) {

		int m = i + (j - i) / 2;
		if (data[i] < data[j])
			swap(data, i, j);
		if (data[m] > data[j])
			swap(data, m, j);
		if (data[m] > data[i])
			swap(data, m, i);

		return data[i];

	}
}
 

通常我們在進行快速排序時，關鍵資料（即基準元素）一般選取序列的第一個元素，但在序列大部分有序時，這會致使最壞時間複雜度O(n^2)的出現，為了避免這種情況的發生，我們可以選擇以下幾種方法對其進行優化：

• 三數取中；
• 優化遞迴操作；
• 使用並行或多執行緒處理子序列；
• 隨機選擇關鍵資料進行快排，可以使用rand()方法；
• 當待排序序列的長度分割到一定大小後，使用插入排序；
• 在一次分割結束後，可以把與 Key 相等的元素聚在一起，繼續下次分割時，不用再對與 key 相等元素分割。

不穩定！