算法详解之快速排序算法

算法思想

快速排序 采用 “分而治之” 的策略：使用 基准值 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都要小于基准值，另外一部分的所有数据都要大于基准值。然后按此方法对这两部分数据进行快速排序，整个排序过程可以 递归 进行，以此达到整个数据集变成有序序列。

算法步骤

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);
}

注意： 选取基准值的位置要和遍历的开始方向相反，这样可以增大对比跨度，减少分区次数。