【排序算法】经典排序算法之快速排序

快速排序的基本思想是分治法，即按照范围内的第一个元素划分为两个部分，再归并排序。
整体排序的过程有点类似建立平衡二叉树的过程。

算法描述

1、假设数组长度为len，low = 0，high = len-1。以数组low为标准，根据和首元素的大小关系将待排序数组分为两个部分，返回分组index。
2、数组被划分为两部分0到index和index+1到high。
3、重复第1、2步，直到low >= high为止。

复杂度和稳定性

时间复杂度是O(nlog2n),空间复杂度是O(n)
快速排序每次将待排序数组分为两个部分，在理想状况下，每一次都将待排序数组划分成等长两个部分，则需要logn次划分。
而在最坏情况下，即数组已经有序或大致有序的情况下，每次划分只能减少一个元素，快速排序将不幸退化为冒泡排序，所以快速排序时间复杂度下界为O(nlogn)，最坏情况为O(n^2)。在实际应用中，快速排序的平均时间复杂度为O(nlogn)。
不稳定，在排序的过程中很有可能打乱数据的先后顺序。

模拟排序过程

以数据21,39,18,10,40,3,15,51为例
第一次排序，以21作为标准，将数组划分为两部分。划分过程中，数组元素变化如下所示。
15 39 18 10 40 3 15 51 
15 39 18 10 40 3 39 51 
15 3 18 10 40 3 39 51 
15 3 18 10 40 40 39 51 
15 3 18 10 40 40 39 51 
15 3 18 10 40 40 39 51 
15 3 18 10 21 40 39 51 
以后针对每个划分的部分进行排序，直到low大于等于high就表示排序结束了。

核心代码

private static int actualSort(int[] array, int low, int high) {
	int temp = array[low];
	while (low < high) {
		while (high > low && array[high] >= temp ) {
			high--;
		}
		array[low] = array[high];
		while (low < high && array[low] <= temp) {
			low++;
		}
		array[high] = array[low];
	}
	array[low] = temp;
	return low;
}

完整代码

public class Sort {
	private static int actualSort(int[] array, int low, int high) {
		int temp = array[low];
		while (low < high) {
			while (high > low && array[high] >= temp ) {
				high--;
			}
			array[low] = array[high];
			while (low < high && array[low] <= temp) {
				low++;
			}
			array[high] = array[low];
		}
		array[low] = temp;
		return low;
	}
	private static void quickSort(int[] array, int low, int high) {
		if (low >= high){
			return;
		}
		int index = actualSort(array, low, high);
		quickSort(array, low, index);
		quickSort(array, index+1, high);
	}
	private static void printf(int[] array) {
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		int array[] = { 21, 39, 18, 10, 40, 3, 15, 51 };
		quickSort(array, 0, array.length-1);
		printf(array);
	}
}

JDK API 

Colletions.sort()以及Arrays.sort()针对基本数据类型排序，底层实现是快速排序。