快速排序

声明：
主要代码和部分算法说明参考自算法(第四版)，这里将代码列出，是想和大家交流一些学习心得。

1.思想

快速排序在每一次的排序中都会完成两件事
1.找到基准数(常设为首元素)在序列中正确的位置
2.使基准数左边的序列的值都小于该基准数，基准数右边的序列的值都大于该基准数

那么如何完成这两件事呢？
以如下序列为例
6 1 2 7 9 3 4 5 10 8
基准数：6
并且我们需要两个帮手(索引i和索引j)

索引i的目的：找到大于或等于基准数的数
索引j的目的：找到小于或等于基准数的数
为什么要等于？
虽然会不必要的进行一些等值的交换，但是这样会避免算法的运行时间变为平方级别。

说明：
本算法中，i和j谁先移动是无所谓的，所以我们不妨让i先移动(一会说明原因)

下面索引i开始向右移动，找到比6大的数就停止，否则继续向右移动。

直到i移动到7位置，此时i的任务完成，此时j开始向左移动，找到比6小的数就停止，否则继续向左移动。

直至j移动到5的位置，此时交换7和5的位置：

然后i继续移动到9：

j继续移动到4：

交换9和4：

补充说明：
当i>=j时，此时的j就是基准数的位置，由于本算法是在每次i和j都移动一遍后再进行i和j的大小关系的判断，所以i和j谁先移动是无所谓的。但是在某些算法中，判断i和j的大小关系如果在前面，那么会造成什么结果？就是当i先移动时，移动过程中和j相遇了，此时i==j，这时候确定j是基准数的位置，但是致命的问题是，j所指向的元素永远是大于基准数的，那么最后将这个大于基准数的数和基准数交换之后，就会造成基准数前面的数不都是小于它的了，所以在这种算法中，必须是j先移动的。
ps：大家可以画画图想想

好，经过一遍乱糟糟的解释说明之后，继续回归正题，接着i继续寻找比6大的数，到9的位置：

j继续移动到3的位置：

此时，继续进行判断i和j的大小关系(之前的判断省略了)，此时发现i>=j成立，则j所在位置就是基准数6的正确位置。
然后交换6和3：

注：
但是上面序列中，只有6的位置是一定正确的，其他元素的位置则不一定正确。
快排采用了迭代的思想，当确定了6的位置后，再用同样的方法去确定6左边序列的基准数和6右边的基准数，如此迭代下去，直至序列只剩下一个元素，就完成了排序。

2.代码

算法核心代码：

import edu.princeton.cs.algs4.StdRandom;

public class Quick {

    // 升序排序
    public static void sort(Comparable[] a) {
        //StdRandom.shuffle(a); //打乱数组
        sort(a, 0, a.length-1);
    }

    private static void sort(Comparable[] a, int lo, int hi){
        if(hi <= lo) return; //集合只有一个元素或者无元素时，不需要排序
        int j = partition(a, lo, hi); //切分，返回基准数5、
        sort(a, lo, j-1); //排序基准数前的集合     
        sort(a, j+1, hi); //排序基准数后的集合
    }

    private static int partition(Comparable[] a, int lo, int hi) {
        int i = lo, j = hi+1; //hi+1中+1的目的是为了配合下面的--j
        Comparable v = a[lo]; //获得当前基准数
        while(true){
            while(Example.less(a[++i],v)) 
                if(i == hi) //防止越界
                    break;
            while(Example.less(v,a[--j])) 
                if(j == lo) //防止越界，但是此代码是冗余的，因为a[lo]不可能小于它自己
                    break;
            if(i >= j) { 
                break;
            }
            Example.exch(a, i, j);
        }
        Example.exch(a, lo, j);
        return j; //返回基准数角标
    }
}

注：上面我为了配合我的示例图把打乱数组的代码给注释掉了，但是它其实是很有用的，因为打乱数组后，我们可以尽量让基准数出现在中间，而不是出现那种第一次基准数是最小元素，第二次基准数是次小元素那种极端情况了。

测试代码：

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdOut;

//p153  排序算法类的模板
public class Example {

    //对数组中的元素(实现了Comparable接口)进行排序
    public static void sort(Comparable[] a){
//      //选择排序
//      Selection.sort(a);

//      //插入排序
//      Insertion.sort(a);

//      //希尔排序
//      Shell.sort(a);

        //快速排序
        Quick.sort(a);
    }

    //判断v是否小于w
    public static boolean less(Comparable v,Comparable w){
        //如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数
        return v.compareTo(w) < 0;
    }

    //交换两个元素的位置
    public static void exch(Comparable[] a, int i, int j){
        Comparable t = a[i]; a[i] = a[j]; a[j] = t;
    }

    //打印数组
    public static void show(Comparable[] a){
        for(int i = 0; i<a.length; i++)
            StdOut.print(a[i]+" ");
        StdOut.println();
    } 

    //判断数组a是否有序
    public static boolean isSorted(Comparable[] a){
        for(int i=1; i<a.length; i++){
            if( less(a[i],a[i-1]) ) {
                return false; //因为默认升序排列
            }
            //System.out.println("判断是否有序中："+a[i-1]+"小于"+a[i]);
        }
        return true;
    }

    //测试
    public static void main(String[] args) {
        //@SuppressWarnings("deprecation")
        //String[] a = In.readStrings();
        Integer[] a = {6,1,2,7,9,3,4,5,10,8}; 
        sort(a);
        if(isSorted(a)) System.out.println("有序");
        show(a);
    }

}

3.测试结果