快速排序

快速排序

快速排序就是分割交换的排序方法，是目前公认的最佳排序方法，在最快以及平均情况下，时间复杂度为O(nlogn)。最坏情况（数据本身就有序）就是每次挑中的基准值不是最大就是最小，其时间复杂度为O(n^2);不稳定，在最差情况下的空间复杂度为O(n),而最佳情况下为O(nlogn)。快速排序法是平均运行时间最快的排序法。

快速排序的思想：它的原理和冒泡排序一样，都是用交换的方式，不过它会现在数据中找一个基准，把小于这个基准的数据放在左边，大于基准的放在右边。再以同样的方式处理两边的数据。

现定义两个下标，low和high分别指向第一个和最后一个，low从前往后走，high从后往前走，一般第一次以第一个元素为基准，把小于这个基准的数据放在左边，大于基准的放在右边，比较完一趟，确定了选的基准的有序位置，且基准左边的都比基准小，右边的都比基准大，然后在再这个有序元素进行两边同样的比较，直至所有的元素位置都确定了就排序完了。

动态示意图：

1、递归法

import java.util.Arrays;

/**
 * @ClassName TestDemo6
 * @Description 快速排序 递归
 * @Author lzq
 * @Date 2018/12/12 19:57
 * @Version 1.0
 **/
public class TestDemo6 {
    public static void main(String[] args) {
        int[] array = {20,1,9,56,25,32,87,45,12,69,54,19};
        System.out.println(Arrays.toString(array));
        quickSort(array);
        System.out.println(Arrays.toString(array));
    }

    /**
     * 快速排序
     * @param array
     */
    private static void quickSort(int[] array) {
        if(array == null || array.length == 0) {
            return;
        }
        sort(array,0,array.length-1);
    }

    /**
     * 递归的排序数据
     * @param array
     * @param start
     * @param end
     */
    private static void sort(int[] array,int start,int end) {
        int par = partion(array,start,end);
        if(par > start+1) {  //排序左边
            sort(array,start,par-1);
        }
        if(par < end-1) {  //排序右边
            sort(array,par+1,end);
        }
    }


    /**
     * 一趟快排
     * 确定一个基准，把小于基准的数据移到前面去，大于基准的移到后面，确定基准的位置
     * @param array
     * @param low
     * @param high
     * @return
     */
    public static int partion(int[] array,int low,int high) {
        int temp = array[low];  //以第一个元素为基准，基准值赋值给temp
        while(low < high) {
            //从后往前，大于基准的数据不管，小于基准的移动到前面去
            while(low < high && array[high] > temp) {
                --high;
            }
            /*
             * 出了上面循环，high指针肯定指向它找到的后面的第一个小于基准的数据
             * 把该数据移到到前面
             */
            array[low] = array[high];

            //从前往后，小于基准的数据不管，大于基准的移动到后面去
            while(low < high && array[low] <= temp) {
                ++low;
            }
            /*
             * 出了上面循环，low指针肯定指向它找到的前面的第一个大于于基准的数据
             * 把该数据移到到后面
             */
            array[high] = array[low];
        }
        /*
         *最后出来，low和high指针在同一位置，都指向基准应该放置的位置
         * 小于它的都在前面，大于它的都在后面
         */
        array[low] = temp;
        /*
         *把基准最后的位置返回出去，基准的位置已经确定，即基准已经有序
         *后面分别在这个基准位置两边重复上面的操作，用以排序当前基准两
         *边的数据
         */
        return low;
    }
}

运行结果：

[20, 1, 9, 56, 25, 32, 87, 45, 12, 69, 54, 19]
[1, 9, 12, 19, 20, 25, 32, 45, 54, 56, 69, 87]

2、非递归法

就是用栈的方式去实现：

不停的出栈入栈到最后把栈出空即可：

/**
 * @ClassName TestDemo2
 * @Description 非递归实现快速排序
 * @Author lzq
 * @Date 2018/10/27 21:49
 * @Version 1.0
 **/
public class TestDemo2 {
    public static void main(String[] args) {
        int[] array = {20,23,98,54,12,15,19,3,46,78,59,84};
        System.out.println(Arrays.toString(array));
        quickSort(array);
        System.out.println(Arrays.toString(array));
    }


    /**
     * 利用栈非递归的排序数据
     * @param array
     * @param start
     * @param end
     */
    private static void quickSort(int[] array,int start,int end) {
        if(array == null || array.length == 0) {
            return;
        }
        int[] stack = new int[array.length];  //一个数组实现的栈
        int top = 0;
        int low = 0;
        int high = array.length-1;
        int once = once(array,low,high);

        //入栈
        if(once > low+1) { //用以排序左边
            stack[top++] = low;
            stack[top++] = once-1;
        }
        if(once < high-1) {  //用以排序右边
            stack[top++] = once+1;
            stack[top++] = high;
        }

        //出栈
        while(top > 0) {
            high = stack[--top];
            low = stack[--top];
            once = once(array,low,high);

            if(once > low+1) {
                stack[top++] = low;
                stack[top++] = once-1;
            }
            if(once < high-1) {
                stack[top++] = once+1;
                stack[top++] = high;
            }
        }
    }

    /**
     * 一趟快速排序
     * @param array
     * @param start
     * @param end
     * @return
     */
    private static int once(int[] array,int start,int end) {
        int tmp = array[start];
        while(start < end) {
            while(start < end && array[end] >= tmp) {
                --end;
            }
            array[start] =  array[end];  //把比基准tmp大的数字移到后面

            while(start < end && array[start] <= tmp) {
                ++start;
            }
            array[end] = array[start];  //把比基准tmp小的数字移到前面
        }
        array[start] = tmp;   //把基准放在它该放的位置
        return start;        //返回基准的位置，后面分别在这个基准位置两边重复上面的操作
    }

}

运行结果：

[20, 23, 98, 54, 12, 15, 19, 3, 46, 78, 59, 84]
[3, 12, 15, 19, 20, 23, 46, 54, 59, 78, 84, 98]

快速排序基准位置的选择和快速排序的优化