数据结构与算法之快速排序

快速排序是对冒泡排序的一种改进，是所有内部排序算法中平均性能最优的排序算法。其基本思想是基于分治法的：在待排序数组L[1…n]中任取一个元素key作为基准，从数组的两端开始扫描。设两个指示标志（low指向起始位置，high指向末尾)，先从后向前扫描（high递减），如果high位置的元素小于key，就交换low和high位置的元素，然后从前向后扫描（low递增），如果low位置的元素大于key，就交换low和high位置的元素。重复上述过程，直到low>=high，然后把基准放到low位置上，一趟排序就完成了，将一个元素（基准）放到了最终位置上，不产生有序子序列。将待排序数组划分为两部分即L[1…k-1]和L[k+1…n]，使得前半部分L[1…k-1]所有元素小于pivot，后半部分L[k+1…n]所有元素大于或等于pivot。接着采用递归的方式分别对前半部分和后半部分排序，直到每部分只有一个元素或空为止，即所有元素放在了最终位置上。
　　之所以快速排序比较快，是因为相比于冒泡排序，每次交换是跳跃式的。每次排序时选取一个基准，将小于基准的数全部放到基准点的左边，将大于或等于基准的数全部放到基准的右边，在每次交换时不会像冒泡排序一样只能在相邻的数之间进行交换，增大了交换距离，减少了总的比较和交换次数，加快了速度。在最坏情况下，仍可能交换相邻的两个数。

对于基准位置的选取一般有三种方法：固定切分，随机切分和三取样切分。
固定切分是一般选取无序序列中的第一个元素作为基值，代码如下

public class QuickSort {
	
	/*
     * 快速排序的核心
     * 用段落的第一个元素作为切分的标准
     * 将小于它的都放在左部分，大于它的都放在右部分
     * 从左到右找大的，从右到左找小的，做交换
     * 最后找到最靠右的小于标准元素的元素与标准元素进行交换
     */
	private static int partition(int[] array, int low, int high) {
		int key = array[low];	//固定切分
		while(low<high) {
			
			while(low<high && array[high]>=key) high--;//从后往前扫描，找比基值小的数
			array[low] = array[high];	//把比基值小的数放到前面(左边)
			
			while(low<high && array[low]<=key) low++;//从前往后扫描，找比基值大的数
			array[high] = array[low];	//把比基值大的数放到前面(右边)
			
		}
		array[high] = key;
		return high;
		//执行完一次的partition切分方法，得到一个左边的数全部小于基值，右边的数大于基值的序列
	}
	
	public static void sort(int[] array,int low,int high) {
		if (low>=high) return;
		//拿到基值排序后的索引，作为下一次递归的条件，分别对其左边和右边的无序序列进行快速排序
		int index = partition(array,low,high);	
		sort(array, low, index-1);
		sort(array, index+1, high);
	}

}

快速排序性能分析：

空间复杂度：因为快速排序是递归的，所以需要借助一个递归工作栈来保存每一层递归调用的必要信息，容量应与递归调用的最大深度一致。最坏情况下n-1次递归调用，栈的深度为O(n)；最好和平均情况下栈的深度为O(log₂n)。所以，空间复杂度在最坏情况下为O(n)，平均情况下为O(log₂n)。

时间复杂度：快速排序的性能主要取决于划分操作的好坏。最坏情况下待排序数组基本有序或基本逆序时，每一次递归划分的两个区域分别包含n-1个元素和0个元素，快速排序退化成冒泡排序，时间复杂度为O(n²)。最好情况下最平衡划分，两个子数组长度不超过n/2，时间复杂度为O(nlog₂n)。而快速排序平均情况下运行时间接近于最好情况下的运行时间，即时间复杂度在最坏情况下为O(n²)，平均情况下为O(log₂n)。

稳定性：如果右端区间有两个相同的关键字，且均小于基准，那么交换到左端区间后，它们的相对次序会变化，即快速排序不稳定。例如，表L={3， 2， 2}，经过一趟排序后L={2， 2， 3}，最终结果是L={2， 2， 3}，2与2的相对次序发生了变化

根据性能分析，那么优化快速算法的方式应该是在不增大空间复杂度的前提下对时间复杂度减小，为了不让快速排序退化成冒泡排序，那么我们要让每次递归划分的两个区域平衡，可以通过改进区分方式去实现。

随机切分是常用的一种切分，效率高，最坏情况下时间复杂度有可能为O(n²)
三取样切分最理想，具体操作：选取数组的头尾和中间这3个元素，取这3个元素的中间值作为基准，代码如下

public class QuickSort_optimize {
		/*
	     * 快速排序的核心
	     * 指定第一个、最后一个和处于中间位置的元素中的中位数作为基准元素
	     * 将小于它的都放在左部分，大于它的都放在右部分
	     * 从左到右找大的，从右到左找小的，做交换
	     * 最后找到最靠右的小于标准元素的元素与标准元素进行交换
	     */
		private static int partition(int[] array, int low, int high) {
			
			//三数取中
			int mid=(low+high)/2;
		          if(array[mid]>array[high]){
		              swap(array[mid],array[high]);
		          }
		          if(array[low]>array[high]){
		              swap(array[low],array[high]);
		          }
		          if(array[mid]>array[low]){
		              swap(array[mid],array[low]);
		          }
		         int key=array[low];
		         
			while(low<high) {
				
				while(low<high && array[high]>=key) high--;//从后往前扫描，找比基值小的数
				array[low] = array[high];	//把比基值小的数放到前面(左边)
				
				while(low<high && array[low]<=key) low++;//从前往后扫描，找比基值大的数
				array[high] = array[low];	//把比基值大的数放到前面(右边)
				
			}
			array[high] = key;
			return high;
			//执行完一次的partition切分方法，得到一个左边的数全部小于基值，右边的数大于基值的序列
		}
	
		
		private static void swap(int a, int b) {
			int temp = a;
			a = b;
			b = temp;
		}


		public static void sort(int[] array,int low,int high) {
			if (low>=high) return;
			//拿到基值排序后的索引，作为下一次递归的条件，分别对其左边和右边的无序序列进行快速排序
			int index = partition(array,low,high);	
			sort(array, low, index-1);
			sort(array, index+1, high);
		}
	
}