内部排序：快速排序

基本思想
设当前待排序的数组无序区为R[low..high]，利用分治法可将快速排序的基本思想描述为：
分解：
在R[low..high]中任选一个记录作为基准（Pivot），以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos-1)和R[pivotpos+1..high]，并使左边子区间中所有记录的关键字均小于等于基准记录（不妨记为pivot）的关键字pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置（pivotpos）上，它无需参加后续的排序。
注意：划分的关键是要求出基准记录所在的位置pivotpos，划分的结果可以简单地表示为（注意pivot=R[pivotpos]）：
R[low..pivotpos-1].keys ≤ R[pivotpos].key ≤ R[pivotpos+1..high].keys
其中low≤pivotpos≤high。

求解：
通过递归调用快速排序对左、右子区间R[low..pivotpos-1]和R[pivotpos+1..high] 快速排序。
组合：

因为当“求解”步骤中的两个递归调用结束时，其左、右两个子区间已有序。对快速排序而言， “组合”步骤不需要做什么，可看作是空操作。

代码实现：

package com.daojia.sort;

import java.util.Arrays;

public class QucikSort implements Sorter {

	@Override
	public void sort(int[] array) {		
	
		quickSort(array,0,array.length-1);
	}
	
	public void quickSort(int[] array,int low ,int high){

		if(low < high ){			
			int pivot = array[low],i=low,j=high;//初始基准点
			while(i<j ){//两侧指针靠拢
				
				while(i<j && array[j] >= pivot){
					j --; //右侧指针左移				
				}
				if(i<j){
					array[i] = array[j]; //基准点指向
					i++; //左侧指针右移
				}
				while(i<j && array[i]<= pivot ){
					i++; //左侧指针右移
				}
				if( i < j){
					array[j] = array[i];
					j --;
				}
			}
			array[i] =pivot;	
			System.out.println("pos="+i+":"+array[i]+",array="+Arrays.toString(array));
			quickSort(array,low,i-1); //递归
			quickSort(array,i+1,high);			
			
		}
	}	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] array = {94,12,34,76,26,9,0,37,55,76,37,5,68,83,90,37,12,65,76,49};
		System.out.println("   source array="+Arrays.toString(array));
		new QucikSort().sort(array);
		System.out.println("after quick array="+Arrays.toString(array));
	}

}

排序过程
采用分治的思想对待排序数组进行划分。分治法的基本思想是：
将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。
快速排序，主要是求得一个合理的划分，从而基于此划分来分治排序。使用简单划分方法的思想是：
第一步：
设置两个指针i和j，它们的初值分别为区间的下界和上界，即i=low，i=high； 选取无序区的第一个记录R[i](即R[low])作为基准记录，并将它保存在变量pivot中；
第二步：
首先，令j自high起向左扫描，直到找到第1个关键字小于pivot.key的记录R[j]，将R[j]移至i所指的位置上，这相当于R[j]和基准R[i]（即pivot）进行了交换，使关键字小于基准关键字pivot.key的记录移到了基准的左边，交换后R[j]中相当于是pivot；
然后，令i指针自i+1 位置开始向右扫描，直至找到第1个关键字大于pivot.key的记录R[i]，将R[i]移到i所指的 位置上，这相当于交换了R[i]和基准R[j]，使关键字大于基准关键字的记录移到了基准的右边， 交换后R[i]中又相当于存放了pivot；
接着，令指针j自位置j-1开始向左扫描，如此交替改变扫 描方向，从两端各自往中间靠拢，直至i=j时，i便是基准pivot最终的位置，将pivot放在 此位置上就完成了一次划分。
快速排序示例过程，如下所示：

   source array=[94, 12, 34, 76, 26, 9, 0, 37, 55, 76, 37, 5, 68, 83, 90, 37, 12, 65, 76, 49]
pos=19:94,array=[49, 12, 34, 76, 26, 9, 0, 37, 55, 76, 37, 5, 68, 83, 90, 37, 12, 65, 76, 94]
pos=10:49,array=[12, 12, 34, 37, 26, 9, 0, 37, 5, 37, 49, 76, 68, 83, 90, 55, 76, 65, 76, 94]
pos=4:12,array=[5, 12, 0, 9, 12, 26, 37, 37, 34, 37, 49, 76, 68, 83, 90, 55, 76, 65, 76, 94]
pos=1:5,array=[0, 5, 12, 9, 12, 26, 37, 37, 34, 37, 49, 76, 68, 83, 90, 55, 76, 65, 76, 94]
pos=3:12,array=[0, 5, 9, 12, 12, 26, 37, 37, 34, 37, 49, 76, 68, 83, 90, 55, 76, 65, 76, 94]
pos=5:26,array=[0, 5, 9, 12, 12, 26, 37, 37, 34, 37, 49, 76, 68, 83, 90, 55, 76, 65, 76, 94]
pos=8:37,array=[0, 5, 9, 12, 12, 26, 34, 37, 37, 37, 49, 76, 68, 83, 90, 55, 76, 65, 76, 94]
pos=6:34,array=[0, 5, 9, 12, 12, 26, 34, 37, 37, 37, 49, 76, 68, 83, 90, 55, 76, 65, 76, 94]
pos=14:76,array=[0, 5, 9, 12, 12, 26, 34, 37, 37, 37, 49, 65, 68, 55, 76, 90, 76, 83, 76, 94]
pos=12:65,array=[0, 5, 9, 12, 12, 26, 34, 37, 37, 37, 49, 55, 65, 68, 76, 90, 76, 83, 76, 94]
pos=18:90,array=[0, 5, 9, 12, 12, 26, 34, 37, 37, 37, 49, 55, 65, 68, 76, 76, 76, 83, 90, 94]
pos=15:76,array=[0, 5, 9, 12, 12, 26, 34, 37, 37, 37, 49, 55, 65, 68, 76, 76, 76, 83, 90, 94]
pos=16:76,array=[0, 5, 9, 12, 12, 26, 34, 37, 37, 37, 49, 55, 65, 68, 76, 76, 76, 83, 90, 94]
after quick array=[0, 5, 9, 12, 12, 26, 34, 37, 37, 37, 49, 55, 65, 68, 76, 76, 76, 83, 90, 94]

算法分析

时间复杂度
最好情况
在最好情况下，每次划分所取的基准都是当前无序区的”中值”记录，划分的结果是基准的左、右两个无序子区间的长度大致相等，总的关键字比较次数：0(nlgn)。
最坏情况
最坏情况是每次划分选取的基准都是当前无序区中关键字最小（或最大）的记录，划分的结果是基准左边的子区间为空（或右边的子区间为空），而划分所得的另一个非空的子区间中记录数目，仅仅比划分前的无序区中记录个数减少一个。
因此，快速排序必须做n-1次划分，第i次划分开始时区间长度为n-i+1，所需的比较次数为n-i(1≤i≤n-1)，故总的比较次数达到最大值：n(n-1)/2 = O(n^2)
如果按上面给出的划分算法，每次取当前无序区的第1个记录为基准，那么当文件的记录已按递增序（或递减序）排列时，每次划分所取的基准就是当前无序区中关键字最小（或最大）的记录，则快速排序所需的比较次数反而最多。

空间复杂度
快速排序在系统内部需要一个栈来实现递归。若每次划分较为均匀，则其递归树的高度为O(logn)，故递归后需栈空间为O(logn)。最坏情况下，递归树的高度为O(n)，所需的栈空间为O(n)。

排序稳定性

快速排序是不稳定的。

*****************

冒泡还是好理解的，快速排序我是一下写不出来的。核心思想是找到基准，并根据基准划分左右子区间（有序的）。再就是递归进行子区间排序。所以代码上也是主要在处理这一块上。

参考：

http://shiyanjun.cn/archives/800.html