排序-快速排序之固定位置选取基准法（递归/非递归）

快速排序

• 固定位置选取排序：数据越有序，复杂度越高
• 随机选取基准排序 请点击查看
• 三分取中法 请点击查看
• 基于三分取中法的几种优化 请点击查看

快速排序（递归）：好：0(nlog2n), 坏：O(n2). 空间复杂度O(nlog₂n) 不稳定

好情况：Partition 每次都划分得很均匀。

坏情况：当待排序数组是正序或者逆序的时候。(退化成选择排序了)

平均时间复杂度

快速排序的平均时间复杂度也是：O(nlogn)
空间复杂度

其实这个空间复杂度不太好计算，因为有的人使用的是非就地排序，那样就不好计算了（因为有的人用到了辅助数组，所以这就要计算到你的元素个数了）；我就分析下就地快速排序的空间复杂度吧；
首先就地快速排序使用的空间是O(1)的，也就是个常数级；而真正消耗空间的就是递归调用了，因为每次递归就要保持一些数据；
最优的情况下空间复杂度为：O(logn) ；每一次都平分数组的情况

最差的情况下空间复杂度为：O( n ) ；退化为冒泡排序的情况

选择low位置为基准tmp，然后每次和基准进行比较，,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。

递归快速排序，将其他 n-1 个元素也调整到排序后的正确位置。

递归解法

*
 *功能描述   快排  --递归实现
 * @author  《Boyou》
 * @Date  下午 10:04  2019/1/12 0012
 * @param
 * @return
 */
public class fastsort {
    public static void main(String[] args) {
        Random ran=new Random();
        int[] array=new int[100];
        for (int i = 0; i <100 ; i++) {
           array[i] = ran.nextInt(100)+1;
        }
        quicksort(array);
        System.out.println(Arrays.toString(array));

    }
    public static void quicksort(int[] array){
        quick(array,0,array.length-1);
    }

    public static void quick(int[] array, int low,int high){
        int par=parvion(array,low,high);
        if (par>low+1){
            quick(array,low,par-1);
        }
        if (par<high-1){
            quick(array,par+1,high);
        }
    }
    public static int parvion(int[] array,int low,int high){
        int tmp=array[low];

        while (low<high){
            while (low<high&&tmp<array[high]){
                high--;
            }
            if (low<high){
                array[low]=array[high];
                low++;
            }else break;
            while (low<high&&tmp>array[low]){
                low++;
            }
            if (low<high){
                array[high]=array[low];
                high--;
            }else break;
        }

        array[low]=tmp;
        return low;
    }
}

快速排序： 非递归解法 ：思想和递归解法差不多，只不过左右两边没有序，将新的low和high压入模拟栈中；在调用确定基准并排序的方法；只要栈不为空，那么就需要进行排序

public class fastsort02 {
    public static void main(String[] args) {
        Random ran=new Random();
        int[] array=new int[100];
        for (int i = 0; i <100 ; i++) {
            array[i] = ran.nextInt(100)+1;
        }
        quicksort(array);
        System.out.println(Arrays.toString(array));
    }
    public static void quicksort(int[] array){
        int high=array.length-1;
        int low=0;

        int par=parvion(array,low,high);
        int size=array.length;
        int [] stack=new int[size];
        int top=0;
        if (par>low+1){
            stack[top++]=low;
            stack[top++]=par-1;
        }
        if (par<high-1){
            stack[top++]=par+1;
            stack[top++]=high;
        }
        while (top>0){
            high=stack[--top];
            low=stack[--top];
            par=parvion(array,low,high);
            if (par>low+1){
                stack[top++]=low;
                stack[top++]=par-1;
            }
            if (par<high-1){
                stack[top++]=par+1;
                stack[top++]=high;
            }

        }
    }
    public static int parvion(int[] array,int low,int high){
        int tmp=array[low];
        while (low<high){
            while (low<high&&tmp<array[high]){
                high--;
            }
            if (low<high){
                array[low]=array[high];
                low++;
            }else {
                break;
            }
            while (low<high&&tmp>array[low]){
                low++;
            }
            if (low<high){
                array[high]=array[low];
                high--;
            }else {
                break;
            }
        }
        array[low]=tmp;
        return low;
    }
}