几大排序算法之快速排序（Java实现）

快速排序（Quicksort）是对冒泡排序的一种改进。

快速排序的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

图片来源

递归实现实现：

/*
*工具函数，将比arr[low]小的元素都放到数组左边，比arr[low]打的元素都放到数组右边
*并返回arr[low]的插入位置
*/
static int Partition(int arr[],int low,int high){

        int key=arr[low];

        while (low<high){
        
            while (low<high&&arr[high]>=key){  //从高位找到比key小的元素
                high--;
            }
            if (low<high){         //将比key小的元素放到低端
                arr[low]=arr[high];
                low++;
            }

            while (low<high&&arr[low]<=key){  //从低位找到比key大的元素
                low++;
            }
            if (low<high){         //将比key大的元素放到高端
                arr[high]=arr[low];
                high--;
            }
        }
        arr[low]=key;
        return low;
   }

    /*
    快速排序递归实现
     */
    public static void quickSort(int arr[],int low,int high){
        int point=0;
        if (low<high){
         //把比arr[low]小的元素全放左边，比arr[low]大的元素放到右边
            point = Partition(arr, low , high); 
            quickSort(arr,low,point-1);    //对左边数组进行快速排序
            quickSort(arr,point+1,high);    //对右边数组进行快速排序
        }
    }

快速排序非递归(栈)实现：

   
   /*
*工具函数，将比arr[low]小的元素都放到数组左边，比arr[low]打的元素都放到数组右边
*并返回arr[low]的插入位置
*/
static int Partition(int arr[],int low,int high){

        int key=arr[low];

        while (low<high){
        
            while (low<high&&arr[high]>=key){  //从高位找到比key小的元素
                high--;
            }
            if (low<high){         //将比key小的元素放到低端
                arr[low]=arr[high];
                low++;
            }

            while (low<high&&arr[low]<=key){  //从低位找到比key大的元素
                low++;
            }
            if (low<high){         //将比key大的元素放到高端
                arr[high]=arr[low];
                high--;
            }
        }
        arr[low]=key;
        return low;
   }
   
    /*
    快速排序非递归(栈)实现
     */
    public static void quickSortNull(int arr[],int low,int high){
        int pivot;
        if (low >= high)
            return;
        Stack<Integer> stack = new Stack<Integer>();
        stack.push(low);
        stack.push(high);
        while (!stack.empty()) {
            // 先弹出high,再弹出low（栈的先进后出特性）
            high = stack.pop();
            low = stack.pop();
            //把比arr[low]小的元素全放左边，比arr[low]大的元素放到右边，
            //并返回arr[low]的插入位置，pivot
            pivot = Partition(arr, low, high);
            // 先压low,再压high
            if (low < pivot - 1) {
                stack.push(low);
                stack.push(pivot - 1);
            }
            if (pivot + 1 < high) {
                stack.push(pivot + 1);
                stack.push(high);
            }
        }
    }