QuickSort

　快速排序：
　　快速排序实则为冒泡排序的改进，与冒泡排序相比，其最差的情况下的时间复杂度和冒泡排序相同，但快速排序并不是一个稳定
的排序算法，例如多个相同值的位置有可能在排序之后会改变。
　算法思想：
    于数组中随机一个数为划分点，依次从数组的左右两边开始遍历查找大于以及小于划分点的数，并将两者交换位置。接着以交换
位置之后的数组从该划分点开始继续递归遍历交换直至结束。
　示例：
　　以 4,9,6,5,1,2,23,14 为例
　　第一次：
　　　　　　2，1，4，5，6，9，23，14
　　第二次：
　　　　　　1，2　　　4，　　5，　　6，9，23，14
　　第三次:
　　　　　　1，2　　　4，　　5，　　6，　　9，23，14
　　第四次：
　　　　　　1，2　　　4，　　5，　　6，　　9，　　23，14
　　第五次：
　　　　　　1，2　　　4，　　5，　　6，　　9，　　14，23
　　public static void main(String[] args) {
        int arr[] = {4,9,6,5,1,2,23,14};
        System.out.println("sort before:");
        System.out.println(Arrays.toString(arr));
        quickSort(arr, 0, arr.length-1);
        System.out.println("after quickSort:");
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 快速排序
     * */
    public static void quickSort(int[] arr, int former, int later) {
        if(former<later)
        {    
            int middle = getIntermediate(arr, former, later);
            quickSort(arr, former, middle-1);
            quickSort(arr, middle+1, later);
        }
    }
 
    /**
     * 将数组划分为两部分并返回划分点索引
     * */
    public static int getIntermediate(int[] arr, int former, int later) {
        int inter = arr[former];
        while (former < later) {
            while(arr[later] > inter)
            {
                later --;
            }
            while(arr[former] < inter)
            {
                former ++;
            }
            if(former < later)
            {
                int t = arr[former];
                arr[former] = arr[later];
                arr[later] = t;
            }
        }
        arr[former] = inter;
        return former;
    }