【数据结构】七大排序之快速排序详解（挖坑法快排，非递归快排，二路快排，三路快排）

whisper-h

已于 2023-04-17 17:13:00 修改

阅读量1.5k

点赞数 5

分类专栏：数据结构文章标签：数据结构排序算法算法 java

于 2023-04-15 22:37:01 首次发布

本文链接：https://blog.csdn.net/m0_57248752/article/details/130171439

版权

数据结构专栏收录该内容

24 篇文章 0 订阅

订阅专栏

1.快速排序核心思路

快速排序算法通过多次比较和交换来实现排序，其排序流程如下：

(1)首先设定一个分界值，通过该分界值将数组分成左右两部分。

(2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。

(3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。

(4)重复上述过程。

补充：选取分区点时尽可能的随机，保证分区点两侧都有元素。

分区点的选择：

1.三数取中法：在无序数组的首，中，尾这三个数据中，选择一个排在中间的数据作为分区点。

2.随机数法：在无序数组中随机选取一个数作为分区点。

2.挖坑法快速排序（递归）

2.1步骤

1.设定一个分区点（一般为序列的最左边元素，也可以是最右变的元素）此时最左边的是一个坑。这里选择最左边元素7作为分区点。

2.开辟两个指针，分别指向序列的头结点和尾结点（选取的分区点在左边，则先从右边出发。反之，选取的分区点在右边，则先从左边出发）。

3.从右指针出发依次遍历序列，如果找到一个值比所选的分区点要小，则将此指针所指的值放在坑里，左指针向前移。此时j遍历到1这个位置,1<7，将1填入i所指的坑里。

4.后从左指针出发（选取的分区点在左边，则后从左边出发。反之，选取的分区点在右边，则后从右边出发），依次便利序列，如果找到一个值比所选的分区点要大，则将此指针所指的值放在坑里，右指针向前移。

5. 依次循环步骤4,5，直到左指针和右指针重合时，我们把分区点放入这连个指针重合的位置。

2.2代码（详细注释）

    //挖坑法快速排序
    public static void quickSortHole(int[] arr){
        quickSortInternal(arr,0,arr.length);
    }

    private static void quickSortInternal(int[] arr, int l, int r) {
        //小数组使用直接插入排序最快
        if(r-l<=64){
            insertionSort(arr,l,r);
            return;
        }
        //先找到第一次排序后分区点的索引
        int p=partitionByHole(arr,l,r);
        //将分区点左边元素进行快速排序
        quickSortInternal(arr,l,p-1);
        //将分区点右边元素进行快速排序
        quickSortInternal(arr,p+1,r);
    }

    private static int partitionByHole(int[] arr, int l, int r) {
        //这里分区点定位最左边的值
        int pivot=arr[l];
        //两个指针，分别指向序列的头节点和尾节点
        int i=l;
        int j=r;
        while(i<j){
            //先从后向前遍历
            while(i<j && arr[j]>pivot){
                j--;
            }
            //此时j指针停在第一个小于pivot的地方，将这个值放入i所指的坑里，那么j所指的地方就变为了一个坑
            swap(arr,i,j);
            //然后从前向后遍历
            while(i<j && arr[i]<pivot){
                i++;
            }
            //此时i指针停在第一个大于pivot的地方，将这个值放入j所指的坑里
            swap(arr,i,j);
        }
        //此时，i和j指向同一位置，回填分区点
        arr[i]=pivot;
        return i;
    }

    //直接插入排序,选取无序区间的第一个元素插入到有序区间的正确位置上
    private static void insertionSort(int[] arr, int l, int r) {
        //无序区间[i,r)
        //有序区间[l,i)
        //无序区间的每一个元素遍历一遍
        for(int i=l+1;i<r;i++){
            //将无序区间的第一个元素与有序区间的元素比较
            for(int j=i;j>l;j--){
                if(arr[j]<arr[j-1]){
                    swap(arr,j,j-1);
                }
            }
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

3.非递归快排（用栈实现快速排序）

3.1思路

递归调用的本质就是栈，栈是一个先进后出的数据结构。

1.将区间的左右两边入栈。让right取栈顶元素（是我们后入的区间的右边），再删除栈顶的元素。同样，让left取先入但是后出的元素（区间的左边）。此时我们拿到了一个区间[left,right],我们对这个区间进行一次快速排序。

2.此时一个分区点到了正确的位置，我们继续对左边区间和右边区间的首尾入栈。

3.当栈为空时，说明排序完成。

3.2代码

    //非递归的快排(栈)
    public static void quickSortNonRecursion(int[] arr){
        Deque<Integer>stack=new ArrayDeque<>();
        stack.push(arr.length-1);
        stack.push(0);
        while(!stack.isEmpty()){
            int l=stack.pop();
            int r=stack.pop();
            if(l>=r){
                continue;
            }
            int p=partitionByHole(arr,l,r);
            //处理左半区间
            stack.push(p-1);
            stack.push(l);
            //处理右半区间
            stack.push(r);
            stack.push(p+1);
        }
    }
    private static int partitionByHole(int[] arr, int l, int r) {
        //这里分区点定位最左边的值
        int pivot=arr[l];
        //两个指针，分别指向序列的头节点和尾节点
        int i=l;
        int j=r;
        while(i<j){
            //先从后向前遍历
            while(i<j && arr[j]>pivot){
                j--;
            }
            //此时j指针停在第一个小于pivot的地方，将这个值放入i所指的坑里，那么j所指的地方就变为了一个坑
            swap(arr,i,j);
            //然后从前向后遍历
            while(i<j && arr[i]<pivot){
                i++;
            }
            //此时i指针停在第一个大于pivot的地方，将这个值放入j所指的坑里
            swap(arr,i,j);
        }
        //此时，i和j指向同一位置，回填分区点
        arr[i]=pivot;
        return i;
    }

    //直接插入排序,选取无序区间的第一个元素插入到有序区间的正确位置上
    private static void insertionSort(int[] arr, int l, int r) {
        //无序区间[i,r)
        //有序区间[l,i)
        //无序区间的每一个元素遍历一遍
        for(int i=l+1;i<r;i++){
            //将无序区间的第一个元素与有序区间的元素比较
            for(int j=i;j>l;j--){
                if(arr[j]<arr[j-1]){
                    swap(arr,j,j-1);
                }
            }
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

4.二路快排

对于上面我写的快排，将小于等于基准值的数据全都放到了左边，大于的放到右边了，那么这样就会出现问题。不管是当条件大于等于还是小于等于，当数组中重复元素非常多的时候，等于基准值的元素太多，那么数组就会分成极度不平衡的两个部分，因为等于基准值的一部分总是集中在数组的一边。

此时，使用二路快排就可以进行优化，阻止效率的降低。

4.1思路

1.正如其名，选取最左边为分区点，将整个区间分为两条路，一路是大于等于分区点的元素（橙色部分），一路是小于与分区点的元素（粉色部分）。分区点v的下标此时为l，i指向当前正在扫描的数组元素。区间[l+1,j]为小于分区点的元素区间，区间[j+1,i]为大于等于分区点元素的区间。

2.当arr[i]>=v时，直接i++即可。

3.当arr[i]<v时，交换arr[j+1]和arr[i]。然后j++。

4.当扫描完数组之后，将分区点和j所指元素交换，回填分区点，数组为如下分区。

4.2代码

    //二路快排
    public static void quickSort2(int[] arr){
        quickSortInternal(arr,0,arr.length);
    }

    private static void quickSortInternal(int[] arr, int l, int r) {
        if(r-l<=64){
            insertionSort(arr,l,r);
            return;
        }
        int p=partition(arr,l,r);
        quickSortInternal(arr,l,p-1);
        quickSortInternal(arr,p+1,r);
    }

    private static int partition(int[] arr, int l, int r) {
        //最左边元素作为分区点
        int v=arr[l];
        //初始j指向l
        int j=l;
        //初始i指向分区点后面第一个元素
        for(int i=l+1;i<r;i++){
            if(arr[i]<v){
                swap(arr,i,j+1);
                j++;
            }
        }
        //回填分区点
        swap(arr,l,j);
        return j;
    }

5.三路快排

三路快排就是在快速排序的基础上进一步优化的，它将数据分为三个部分：大于分区点，小于分区点和等于分区点。

5.1思路

1.将数据分为三个部分，i指向当前数组正在处理的元素。

区间[l+1,lt]为小于分区点的元素区间

区间[lt+1,i]为等于分区点的元素区间

区间[gt,r]为大于分区点的元素区间

2.当arr[i]==v时,i++即可。

3.当arr[i]>v时，交换arr[i]和arr[gt-1]

4.当arr[i]<v时，交换arr[i]和arr[lt]。当i和gt重合时，整个数组交换完毕。

5.2代码

    //三路快排
    public static void quickSort3(int[] arr){
        quickSortInternal3(arr,0,arr.length-1);
    }

    private static void quickSortInternal3(int[] arr, int l, int r) {
        if(r-l<=64){
            insertionSort(arr,l,r);
            return;
        }
        int v=arr[l];
        int lt=l;
        int gt=r+1;
        int i=l+1;
        //终止条件为i和gt重合
        while(i<gt){
            if(arr[i]<v){
                swap(arr,lt+1,i);
                lt++;
                i++;
            }else if(arr[i]>v){
                swap(arr,gt-1,i);
                gt--;
            }else{
                i++;
            }
        }
        //回填分区点
        swap(arr,l,lt);
        quickSortInternal3(arr,l,lt-1);
        quickSortInternal3(arr,gt,r);
    }