快速排序

首先我们引入一张思维导图，并且以后的排序博客我将以这位博主的博文为基础，进行代码自我实现，简单介绍以及自我理解。
链接：cnblogs.com/cndarren/p/11787368.html

快速排序

快速排序的思想：快速排序的思想是选取一个基准，定义两个指针，一个指针在前（low），一个指针在后（high）；先从后向前（从high位置开始，high–）找比基准小的值，然后与放到基准位置；再从前向后（从low位置开始，low++）找比基准大的，放到 high 的位置。再从high开始向前找比基准小的值，放到 low 的位置。直到 high 与 low 重合，这时，我们把基准放到low（high）的位置，就把这个序列分割成了两个部分，比基准值大的序列（右半部分），比基准值小的部分（左半部分）。然后在对左边和右边序列再进行上述操作。

我们用图来展示一轮排序的过程，

递归实现：

 public static int partition(int[] arr,int low, int high){ //返回的是基准一次划分之后的位置
        int partition = arr[low];  //选择arr[low]作为基准
        //先从前向后找
        //再从后先前找
        //直到两个指针重合

        int i = low;   //不能改变low和hihg指针的实际值，所以用变量进行保存
        int j = high;
        while(i < j){
            //从后向前
            while(j > i){
                if(arr[j] < partition){ //如果high指向的位置的数字比基准小，放到基准位置也就是 arr[low]
                    arr[i] = arr[j];
                    break;
                }
                j--;
            }
            //先判断一下high 和 low 是否重合
            if(i == j){ //如果重合直接break
              break;
            }
            //从前向后
            while(i < j){
                if(arr[i] > partition){
                    arr[j] = arr[i];
                    break;
                }
                i++;
            }
            //再判断一下
            if(i == j){
               break;
            }
        }

        arr[i] = partition;
        return i;

    }

    public static void quickPass(int[] arr, int low ,int high){
        //中止条件  当两个指针相等或者越界的时候就证明一次排序结束了
        if(low >= high){
            return ;
        }

        int partition = partition(arr,low,high); //返回基准值的位置

        if(partition - low >  1){ //也就是说基准的左边的序列元素个数大于1个
            quickPass(arr,low,partition-1);  //此时进入递归，左边的序列还需要进行快速排序，low = low high = partition -1
        }
        if(high - partition > 1 ){ //也就是说基准的右边序列元素大于1个
            quickPass(arr,partition+1,high); //右边的序列在进行快速排序 low = parititon + 1； high = high;
        }
    }

    public static void  quickSort(int[] arr ){
        if(arr.length < 2 || arr == null){
            return ;
        }

        quickPass(arr,0,arr.length-1);

    }
    

非递归实现（利用栈）：
实现思想：我们进行一次划分后，我们划出了左序列和右序列，我们让两个序列的左边界分右边界都入栈。
这时，栈中存在的就是还需要划分的序列的一个范围元素，我们pop两次，第一次pop取出的是范围的右边界，第二次取出的是范围的左边界。
我们对 arr 中这一边界中的元素再进行一次划分，对比，是否还需要划分，如果还需要划分，那就接着让左边界和右边界入栈，再pop两次，循环往复。直到栈为空位置。当栈为空时，那么就说明这个序列是完全有序的了。

实现：

public static int partition(int[] arr,int low, int high){ //返回的是基准一次划分之后的位置
        int partition = arr[low];  //选择arr[low]作为基准
        //先从前向后找
        //再从后先前找
        //直到两个指针重合

        int i = low;   //不能改变low和hihg指针的实际值，所以用变量进行保存
        int j = high;
        while(i < j){
            //从后向前
            while(j > i){
                if(arr[j] < partition){ //如果high指向的位置的数字比基准小，放到基准位置也就是 arr[low]
                    arr[i] = arr[j];
                    break;
                }
                j--;
            }
            //先判断一下high 和 low 是否重合
            if(i == j){ //如果重合直接break
              break;
            }
            //从前向后
            while(i < j){
                if(arr[i] > partition){
                    arr[j] = arr[i];
                    break;
                }
                i++;
            }
            //再判断一下
            if(i == j){
               break;
            }
        }

        arr[i] = partition;
        return i;

    }
    public static int[] quickSort1(int[] arr){
        Stack<Integer> stack = new Stack(); //定义一个栈
        int low = 0;
        int high = arr.length-1;

        //调用一次划分，先把待排序列分为两部分

        int p = partition(arr,low,high);
        if(p - low >1){  //如果 基准位置距离左指针的长度大于1 ，也就是划分后左序列的数字不止一个。
            stack.push(low);         //把左序列的左边界入栈
            stack.push(p-1);   //右边界入栈
        }

        if(high - p > 1){ //也就是右序列的数字个数大于1
            stack.push(p+1);  //右序列的左边界入栈
            stack.push(high);       //右序列的右边界入栈
        }

        //只要不为空，那就证明有待排序列
        while(!stack.isEmpty()){
            high = stack.pop(); //取出待排序列的右边界
            low = stack.pop();   //待排序列的左左边界

            //我们对边界内的数字在进行一次划分
            p = partition(arr,low,high);

            //再对左序列和右序列进行判断，如果还需要划分，那就再次让左边界
            //和右边界入栈，再出栈，进行一次划分，再判断，直到栈空为止（也就是待排序列为空为止）

            if(p - low > 1){
                stack.push(low);
                stack.push(p-1);
            }
            if(high - p > 1){
                stack.push(p+1);
                stack.push(high);
            }

        }

        return arr;
    }

时间复杂度：O(n* log2 n)。因为我们是不断的一分为二，一分为二的过程。
空间复杂度 ： O(log2 n)。 我们进行一次划分的时候不断的在借助空间，虽然最后会被销毁，但是一共借助了（log 2 n）次
稳定性：不稳定。

优化：对于快速排序，如果完全有序（也就是最好情况），我们会退化为选择排序
如果是最坏情况，那么时间复杂度会提升到 O(n^2);

对于最好情况，我们可以让基准不再是arr【low】，而是一个随机的下标，这样再进行第一次划分的时候，就会直接判断为完全有序。时间复杂度会直接降为 O(n) ;

对于最坏情况，我们可以在进行几次划分后，对待排序列的长度进行判断，如果待排序列的长度小于一定的值，我们直接采用直接插入排序，因为直接插入排序的特性就是越有序越快。当待排序列已经划分了几次，那么它的有序性就会相对较高，这时进入直接插入排序会更快！

以下是把基准选择为中间下标的实现思想：
思路很简单，只要选择好下标之后，直接和arr【low】进行交换即可，其余不变。
代码参考：

    public static void quicksort(int[] arr, int low ,int high){
        if(arr.length <2 || arr == null || low <0 || high > arr.length-1)return;

        int parition = parition(arr,low,high);
        if(parition - low > 1){
            parition(arr,low,parition-1);
        }
        if( high - parition > 1){
            parition(arr,parition+1,high);
        }
    }
    public static int parition (int[] arr,int low ,int high){
        int pivot = arr[(low+high) >> 1];
        swap(arr,low,(low+high) >> 1);
        int i = low;
        int j = high;
        while(i < j){
            //从后向前找
            while(i < j){
                if(arr[j] <= pivot){
                    arr[i] = arr[j];
                    break;
                }
                j--;
            }
            while(i < j){
                if(arr[i] > pivot){
                    arr[j] = arr[i];
                    break;
                }
                i++;
            }
            if(i == j){
                break;
            }
        }
        arr[i] = pivot;
        return i;
    }

其他实现方式以及双轴快排参考链接