快速排序

原理

1. 从待排序区间选择一个数，作为基准值(par)；
2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长==1，代表已经有序，或者小区间的长度 == 0，代表没有数据。
   非递归方法

public static int partion(int[] array,int low,int high) {
        int tmp = array[low];
        while (low < high) {
            while (low < high && array[high] >= tmp) {
                high--;
            }
            if(low >= high) {
                break;
            }else {
                array[low] = array[high];
            }
            while (low < high && array[low] <= tmp) {
                low++;
            }
            if(low >= high) {
                break;
            }else {
                array[high] = array[low];
            }
        }
        array[low] = tmp;
        return low;
    }
public static void quickSort(int[] array) {
        Stack<Integer> stack = new Stack<>();
        int low = 0;
        int high = array.length-1;
        int par = partion(array,low,high);
        if(par > low+1) {
            stack.push(low);
            stack.push(par-1);
        }
        if(par < high-1) {
            stack.push(par+1);
            stack.push(high);
        }
        while (!stack.empty()) {
            //1、取出数对
            high = stack.pop();
            low = stack.pop();
            //2.par
            par = partion(array,low,high);
            if(par > low+1) {
                stack.push(low);
                stack.push(par-1);
            }
            if(par < high-1) {
                stack.push(par+1);
                stack.push(high);
            }
        }

    }

递归方法
在此链接一个比较全面的解释
https://blog.csdn.net/insistgogo/article/details/7785038

 public static int partion(int[] array,int low,int high) {
        int tmp = array[low];
        while (low < high) {
            while (low < high && array[high] >= tmp) {
                high--;
            }
            if(low >= high) {
                break;
            }else {
                array[low] = array[high];
            }
            while (low < high && array[low] <= tmp) {
                low++;
            }
            if(low >= high) {
                break;
            }else {
                array[high] = array[low];
            }
        }
        array[low] = tmp;
        return low;
    }
    public static void swap(int[] array,int i,int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
    public static void threeNumMid(int[] array,int low,int high) {
        int mid = (low+high)/2;
        if(array[mid] > array[low]) {
            swap(array,low,mid);
        }
        if(array[mid] > array[high]) {
            swap(array,high,mid);
        if(array[low] > array[high]) {
            swap(array,low,high);
        }
    }
    public static void insertSort(int[] array,int low,int high) {
        for (int i = low+1; i <= high; i++) {
            int tmp = array[i];
            int j = i-1;
            for (; j >= low ; j--) {
                if(array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }
    public static void quick(int[] array,int low,int high) {
        //三数取中优化
       /*if(high-low+1 <= 100) {
            insertSort(array,low,high);
            return;
        }

        threeNumMid(array,low,high);*/

        int par = partion(array,low,high);
        if(par > low+1) {
            quick(array,low,par-1);
        }
        if(par < high-1) {
            quick(array,par+1,high);
        }
    }
    public static void quickSort1(int[] array) {
        quick(array,0,array.length-1);
    }