算法詳解之快速排序算法

算法思想

快速排序 採用 “分而治之” 的策略：使用 基準值 通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都要小於基準值，另外一部分的所有數據都要大於基準值。然後按此方法對這兩部分數據進行快速排序，整個排序過程可以 遞歸 進行，以此達到整個數據集變成有序序列。

算法步驟

1. 從數據集中挑選一個元素，我們稱爲 “基準值”（pivot）；
2. 重新排序數列，所有小於基準值的元素移動到基準值的左邊，所有大於基準值的元素移動到基準值的右邊（相同的元素放可以放在任意一邊）。在這一趟分區之後，該基準值就處於數列的中間位置。這個步驟成爲分區（partition）操作；
3. 遞歸的把小於基準值元素的子數列和大於基準值元素的子數列排序；

動圖演示

時間複雜度

快速排序的時間複雜度分爲兩種情況：

• 最壞情況：$O(n ^ 2)$
• 平均情況：$O(n \log_2 n)$

對於快速排序而言，如果待排序數列本身就是有序的或者所有元素都相同的情況下，就會出現要遍歷對比所有的元素，這個時候就會出現最壞運行情況。

代碼實現

JavaScript實現

function quickSort(arr){
	//空數組或數組長度小於2的情況下不需要排序
	if (arr == null || arr.length < 2){
		return;
	}
	partition(arr,0, arr.length - 1);
}
//分區操作
function partition(arr,top,tail){
	if (top >= tail) {
		return;
	}
	//設置左邊界和右邊界
	var left = top, right = tail;
	//基準值取頭法
	var pivot = arr[left];
	while (left < right) {
		//先從右到左檢查小於基準值的元素
		while (left < right && arr[right] >= pivot) {
			right--;
		}
		//將小於基準值的元素移動到左邊
		arr[left] = arr[right];
		//從左到右檢查大於等於基準值的元素
		while (left < right && arr[left] < pivot) {
			left++;
		}
		//將大於或等於基準值的元素移動到右邊
		arr[right] = arr[left];
	}
	//將基準值移動到左邊
	arr[left] = pivot;
	//繼續遞歸左邊的排序
	partition(arr,top,left - 1);
	//繼續遞歸右邊的排序
	partition(arr,left + 1,tail);
}

Python實現

def quickSort(arr):
	if len(arr) < 2:
		return arr
	else:
		pivot = arr[0]  # 基準值爲頭元素
		left = [i for i in arr[1:] if i <= pivot]  # 所有小於或等於基準值的元素組成的子序列
		right = [i for i in arr[1:] if i > pivot]  # 所有大於基準值的元素組成的子序列
		return quickSort(left) + [pivot] + quickSort(right)  # 遞歸調用

Java實現

public void quickSort(int[] arr) {
	if (arr == null || arr.length < 2) {
		return;
	}
	partition(arr,0,arr.length - 1);
}

//基準值取頭法
public void partition(int[] arr,int top,int tail) {
	if (top >= tail) {
		return;
	}
	int left = top, right = tail;
	//基準值取頭法
	int pivot = arr[left];
	while (left < right) {
		while (left < right && arr[right] >= pivot) {
			right--;
		}
		arr[left] = arr[right];
		while (left < right && arr[left] < pivot) {
			left++;
		}
		arr[right] = arr[left];
	}
	arr[left] = pivot;
	partition(arr,top,left - 1);
	partition(arr,left + 1,tail);
}

//基準值取尾法
public void partition2(int[] arr,int top,int tail){
	if (top >= tail){
		return;
	}
	int left = top,right = tail;
	int pivot = arr[right];
	while (left < right) {
		//先從左到右查找大於或等於基準值的元素
		while (left < right && arr[left] < pivot) {
			left++;
		}
		//將大於或等於基準值的元素移動到右邊
		arr[right] = arr[left];
		//再從右到左查找小於基準值的元素
		while (left < right && arr[right] >= pivot) {
			right--;
		}
		arr[left] = arr[right];
	}
	arr[right] = pivot;
	partition2(arr,top,right - 1);
	partition2(arr,right + 1,tail);
}

//基準值取中法
public void partition3(int[] arr,int top,int tail) {
	if (top >= tail) {
		return;
	}
	int left = top, right = tail;
	//基準值取中間數據
	int pivot = arr[(left + right) / 2];
	while (left <= right) {
		//從左到右查找大於基準值的元素
		while (arr[left] < pivot) {
			left++;
		}
		//從右到左查找小於基準值的元素
		while (arr[right] > pivot) {
			right++;
		}
		//將小於基準值的元素移動到左邊，大於基準值的元素移動到右邊
		if (left < right) {
			int temp = arr[left];
			arr[left] = arr[right];
			arr[right] = temp;
			left++;
			right--;
		} else if (left == right) {
			left++;
		}
	}
	partition3(arr,top,right);
	partition3(arr,left,tail);
}

注意： 選取基準值的位置要和遍歷的開始方向相反，這樣可以增大對比跨度，減少分區次數。