从零开始学算法----图解快速排序

快速排序， 应用场景： 数据量大且为线性结构时。

短处：有大量重复数据的时候，性能不好
           单向链式结构处理性能不好（一般来说，链式都不使用）

一次排序过程：

1）取一个高位指针和一个低位指针， 暂存低位指针的值temp

 

 

 2）移动高位指针，如果值比Temp大，继续移动不做处理，如果比temp小，则取出来放在低位指针的位置上

 

 

 

3）然后移动低位指针，如果值比temp小则继续移动不做处理，如果比temp大，则取出来放到高位指针的位置

 

 

 4）然后再移动高位指针，与步骤2相同

5）当有值比temp小时， 把它的值赋给低位指针

 

 

 6）再移动低位指针

 

 

 7）如此变换直到两个指针重合

 

 

 8）把temp的值放在指针重合的位置上

 

 

 9）这样，经过一轮变换后， 我们可以固定一个数（31）的位置， 它前面的都比它小，它后面的都比它大。

然后我们可以利用递归的思想， 对前面部分和后面部分分别排序。

因为每次排序最坏情况下会执行n次, 所以快排的时间复杂度为n*log2N (n 乘以 log以2为底的n的对数 )

看下代码实现：

public static void quickSort(int[] array, int begin, int end) {
        if(begin >= end) {
            return;
        }
        int low = begin;
        int high = end;
        //先找到低位指针的值temp
        int temp = array[low];
        boolean direction = true;//定义true为高位指针从右向左移动
        L1:
        while (low < high) {
            //查看高位指针的值， 与temp比较
            //如果比temp大，高位指针前移一位
            //如果比temp小，高位指针前移一位且把它的值放在低位指针的位置，然后移动低位指针
            if (direction) {
                for (int i = high; i > low; i--) {
                    if (array[i] <= temp) {
                        array[low] = array[i];
                        low++;
                        high=i;
                        //执行到这里后我们要改变策略，开始移动低位指针
                        //所以我们需要定义一个方向direction，在这里取反
                        direction = !direction;
                        //然后还需要让程序回到if (direction)之前的位置
                        //这里不能用break， 因为会直接跳出去
                        //所以我们在if (direction)之前写个标记
                        continue L1;
                    }

                }
                //如果if里面的代码从未进去，让两个指针重合
                high = low;
                //移动低位指针的逻辑
            }else {
                //查看低位指针的值，和temp比较
                //如果比temp小，指针后移一位
                //如果比temp大， 指针后移一位，且把它的值放在高位指针的位置，然后操作高位指针
                for (int i = low; i < high; i++) {
                    if (array[i] >= temp) {
                        array[high] = array[i];
                        high--;
                        low = i;
                        //执行到这里后我们要改变策略，开始移动高位指针
                        direction = !direction;
                        continue L1;
                    }
                }
                //如果if里面的代码从未进去，让两个指针重合
                low = high;
            }

        }
        //while 循环执行完之后，两个指针重合，low==high
        //我们把temp的值放在low的位置
        //此时low（high）左边值的都比它小，右边值的都比它大
        array[low] = temp;
        quickSort(array, begin, low-1);
        quickSort(array, low+1, end);
    }

注意这里调用递归的地方

我刚开始写的时候写成了这样

quickSort(array, 0, low-1);

quickSort(array, low+1, array.length-1);

结果运行起来总是报stackOverFlowError.   

之所以会这样写，还是没有理解递归的思想。虽然我们整个方法里没有地方去对begin/ end赋值， 但因为递归调用（low-1和low+1）被传进去，所以begin和end的取值时不断在变化的， 不能hardcode. 

看看方法调用及排序结果：

@Test
    fun test(){
        val array = intArrayOf(4, 7, 91, 10, 21, 14, 22, 1, 62, 103, 5, 10)
        quickSort(array, 0, array.size - 1)
        for (i in array.indices) {
            print(array[i].toString() + " ")
        }
    }