Java 快速排序

快速排序作为一种快速的排序算法，所以现在就详细的介绍一下 。

快速排序是冒泡的一种改进 都是交换类的排序算法

（ 冒泡排序是每轮都把当前排序范围中最大的数放到最后 ）

快速排序是确定一个PivotKey ，把当前数组范围分成三份，左边是小于PivotKey的，中间是PivotKey，右边是大于PivotKey的

当然可能PivotKey最小 没有左边的部分 ，反之。

快速排序是基于分治策略的一种算法    （分治法的思想是将一个规模为n 的问题分解成k个较小规模的子问题，子问题互相独立且与原问题相同）

快速排序的基本思想是三个步奏：

 1，分解 ： 通常以待排列数组第一个元素为 PivotKet（或用随机选择策略 随机选取其中一个元素作为PivotKey）, 将数组划分成三段 ， 中间是小于PivotKey的元素
 中间是PivotKey 右侧是大于它的元素 （要是PivotKey为最小的元素 就直接去第二步）

 2，递归求解：通过递归手段 对上一步的左边 和 右边的数组进行快速排序

 3,合并 ；由于对于子数组的排列是直接用的原数组，所以在递归结束，整个数组已经是有序的了 不需要额外的合并操作 

上代码，这里的代码只是一种解法  别的解法暂无研究 ，代码有错误  或者不完美的留言指正，你说我就改，就怕你不来

public class Test {

	private static int[] data;
	/**
	 * 对 数组 s 到 e 这一段进行快速排序 步骤如下： 定义 i = s; j = e; i,j 都为数组下标 
	 * 
	 *          从j向前搜索找第一个小于 X 的元素,  i , j 交换 --------------步骤1 
	 *          从i向前搜索找第一个大于 X 的元素,  i , j 交换 --------------步骤2 
	 * 重复步骤 1 2 直到 i = j
	 * 
	 * **** 总的思想就是以PivotKey为中心分解成两拨数的时候 一直都是PivotKey这个数一直在交换 所以我们需要交换一次 就得调转方向
	 * 以便让比较的范围逐渐缩小 也让PivotKey一直向中心靠近
	 */
	public static void Divide(int s, int e) {
		int i, j;
		i = s;
		j = e;
		boolean isLeft = true; // 表示当前PivotKey是在相对于左边一点的位置还是右边一点的位置
				       // 其实就是上一次交换中PivotKey是被换到左边还是右边
		if (i >= j) {
		     return;
		}
		while (i != j) {
			if (data[j] < data[i]) { //  j，i对应的数组元素必有一个是PivotKey  （慢慢根据结果分析得出）
				                     //  当 j = PivotKey，按步骤2 
				                     //  当 i = PivotKey，按步骤1 
				                     //  所以一个判断就搞定  是不是nice
				int temp = data[i];
				data[i] = data[j];
				data[j] = temp;
				isLeft = (isLeft == true) ? false : true;
			}
			if (!isLeft) {    // 每次比较之后，如果PivotKey在右边，根据步骤1，左边的指针后移，反之
				i++;
			} else {
				j--;
			}
		}
		// while循环结束 i,j 相等 停在PivotKey上 所以递归求解时 必须i，j分离
		i--;
		j++;

                //递归时刻  两次递归调用 分别对应分解出的左边和右边的数组
		Divide(s, i);  
		Divide(j, e);
	}
	/**
	 * 
	 * 输出当前数组
	 */
	public static void PrintData() {
		for (int i = 0; i < 10; i++) {
			System.out.print(" " + data[i]);
		}
		System.out.println("");
	}

	public static void main(String[] args) {
		data = new int[10];
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入十个数字进行快速排序");
		for (int m = 0; m < 10; m++) {
			data[m] = scanner.nextInt();
		}
		Divide(0, 9);
		PrintData();
		scanner.close();
	}
}

代码固定了只输入十个数    是为了方便观察结果  数组长度可以自定义，稍微修改下代码即可 

示例输入 ： 41 1 23 14 78 55 69 15 6 51
每次交换后的数组变化 ：
6 1 23 14 78 55 69 15 41 51
6 1 23 14 41 55 69 15 78 51
6 1 23 14 15 55 69 41 78 51
6 1 23 14 15 41 69 55 78 51
1 6 23 14 15 41 69 55 78 51
1 6 15 14 23 41 69 55 78 51
1 6 14 15 23 41 69 55 78 51
1 6 14 15 23 41 51 55 78 69
1 6 14 15 23 41 51 55 69 78

以上面数据为例   说一下第一次分解的过程

开始   ： 41  1  23  14  78  55  69  15  6  51

以41 为PivotKey  ， i = 0， j = 9  ，  data[j] < data[i]   即51<41 不满足 ； 

 j-- 变为8  , 6 <41 满足if判断，交换。  

数组变为 ：6 1 23 14 78 55 69 15 41 51

 然后i++ 变为1  ，1 不满足 , i++ 变为2 ，23 不满足，i++ 变为3  ，14也不满足，i++变为4 ，78满足交换

数组变为：  6 1 23 14 41 55 69 15 78 51

此时j-- ， 变为 7，15 < 41 ,满足 交换

数组变为：  6 1 23 14 15 55 69 41 78 51

此时i++，变为5 ，41 <55  满足交换

数组变为：  6 1 23 14 15 41 69 55 78 51

此时j-- ，变为6 ，69>41 不满足 ，j-- 变为5

 i == j  while循环结束 进入递归。。。。。。。

快速排序的平均时间复杂度 ：O(n*lgn) 最坏时间复杂度为 ： O(n^2)，最好情况：O(nlgn)  空间复杂度 ： O(lgn)  


 * 快速排序的时间复杂度与    划分是否对称   有关；
 *   ***最坏情况** 为：每次递归都划分为产生两个区域分别包含 n-1和 1 个元素  由于分解当前数组这部分的时间复杂度为O(n),
 *   所以快排的时间复杂度T(n)满足：
 *               { O(1)             n<=1
 *   T(n) =  |          
 *               { T(n-1) + O(n)    n>1
 *   解此递归方程得  T(n) = O(n^2)
 * 
 *   ***最好情况*** 为：每次划分的 PivotKey都处在最中间，即产生了两个大小为 n/2的区域
 *               { O(1)             n<=1
 *   T(n) =  |          
 *               { 2T(n/2) + O(n)   n>1
 *   解得 ：  T(n) = O(nlgn)  

快速排序最坏的情况就是待排数据基本有序，退化为冒泡排序，时间复杂度为O(n^2)

快速排序递归过程对应一棵二叉树，其递归工作栈的大小与递归调用二叉树的深度相对应，最好情况下是一棵完全二叉树 

可以证明快速排序在平均情况下时间复杂度也是O(nlgn)   ~~~~~怎么证明的搞不懂

下一讲将最简单的交换类排序：冒泡