排序算法之快速排序

一、快速排序算法介绍

快速排序是对冒泡排序的一种改进，使用分治法来设计算法。它的基本思想是通过一趟排序将待排记录分割成两部分，其中一部分的所有数据都比另一部分的所有数据要小，然后再按此方法对这两部分数据分别进行快速排序，以达到整个数据变成有序序列。快速排序的平均运行时间是O(NlogN)，最坏情况下性能为O(N^2)。

 

二、快速排序实现思路

1．采用“三数取中”的方法选取枢纽元。

2．用枢纽元将数组[A0,A1,A2,A3….,An]分成两个区域，使左区所有数值小于枢纽元，使右区所有数值大于枢纽元。

3. 再对左右两个区域重复第1.2步骤，直至各区域只有一个数。

 

下面看具体实例：

0	1	2	3	4	5	6	7	8
15	8	13	56	43	77	14	89	10

首先选择枢纽元，并将枢纽元放在数组的最前面，方便后续操作：

int[] array = { 15, 8, 13, 56, 43, 77, 14, 89,10 };
public static void selectMiddle(int[] array, int left, int right) {
		int mid = (left + right) / 2;
		if (array[mid] < array[left])
			swap(array, left, mid);
		if (array[right] < array[left])
			swap(array, left, right);
		if (array[right] < array[mid])
			swap(array, mid, right);
		swap(array, left, mid);
	}

public static void swap(int[] array, int a, int b) {
		int temp = array[a];
		array[a] = array[b];
		array[b] = temp;
	}

此时数组变为如下形式：

0	1	2	3	4	5	6	7	8
15	8	13	56	10	77	14	89	43

开始时，left=0,right=8,枢纽元pivot=15;

从右往左寻找比枢纽元小的数，填充到a[left],right--（相当于在a[left]挖了一个坑，将比枢纽元小的数填入，形成一个新的坑）

0	1	2	3	4	5	6	7	8
14	8	13	56	10	77	14	89	43

然后再从左往右找比枢纽元大的数，填充到a[right],left++

0	1	2	3	4	5	6	7	8
14	8	13	56	10	77	56	89	43

再重复上面的步骤，先从右往左，再从左往右，直到left=right 

0	1	2	3	4	5	6	7	8
14	8	13	10	10	77	56	89	43

当left==right，完成一趟快速排序，将pivot填充到left位

0	1	2	3	4	5	6	7	8
14	8	13	10	15	77	56	89	43

public static int partition(int[] array, int left, int right) {
		int pivot = array[left]; //选定枢纽元，保持不变	
		while (left < right) {
			while (left < right && array[right] >= pivot)
				right--;
			array[left] = array[right];
			while (left < right && array[left] <= pivot)
				left++;
			array[right] = array[left];
		}
		array[left] = pivot;
		return left;
	}

完成一次快速排序后，再采用分治法递归调用完成最终排序：

public static void quickSort(int[] array, int left, int right) {
		int pivot;
		if (left < right) {
			// 三分中值法，选出枢纽元放在数组最前面
			selectMiddle(array, left, right);
			// pivot作为枢纽元，较之小的元素在左，较之大的元素在右
			pivot = partition(array, left, right);
			// 对左右数组递归调用快速排序，直到顺序完全正确
			quickSort(array, left, pivot - 1);
			quickSort(array, pivot + 1, right);
		}
	}

最终完整的代码如下：

public class MyQuickSort {
	
	public static void quickSort(int[] array, int left, int right) {
		int pivot;
		if (left < right) {
			selectMiddle(array, left, right);
			pivot = partition(array, left, right);
			quickSort(array, left, pivot - 1);
			quickSort(array, pivot + 1, right);
		}
	}
	
<span style="white-space:pre">	</span>public static void selectMiddle(int[] array, int left, int right){
		int mid = (left + right) / 2;
		if (array[mid] < array[left])
			swap(array, left, mid);
		if (array[right] < array[left])
			swap(array, left, right);
		if (array[right] < array[mid])
			swap(array, mid, right);
		swap(array, left, mid);
	}

	public static void swap(int[] array, int a, int b) {
		int temp = array[a];
		array[a] = array[b];
		array[b] = temp;
	}

	public static int partition(int[] array, int left, int right) {
		int pivot = array[left];
		while (left < right) {
			while (left < right && array[right] >= pivot)
				right--;
			
			array[left] = array[right];
			while (left < right && array[left] <= pivot)
				left++;
			
			array[right] = array[left];
		}
		array[left] = pivot;
		return left;
	}
<span style="white-space:pre">	</span>public static void main(String[] args) {
		int[] array = { 15, 8, 13, 56, 43, 77, 14, 89,10 };
		quickSort(array, 0, array.length - 1);
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
	}

}