【数据结构】排序 —— 快速排序（quickSort）

于 2024-08-05 23:38:47 发布
阅读量451 收藏 10
点赞数 12
分类专栏： 数据结构 文章标签： 数据结构 排序算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75724363/article/details/140923864
版权

Hi~！这里是奋斗的明志，很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~~
🌱🌱个人主页：奋斗的明志
🌱🌱所属专栏：数据结构、LeetCode专栏

在这里插入图片描述

📚本系列文章为个人学习笔记，在这里撰写成文一为巩固知识，二为展示我的学习过程及理解。文笔、排版拙劣，望见谅。

在这里插入图片描述

快速排序

前言

在这里插入图片描述

一、快速排序

1.概念

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为： 任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有 元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

2.快排递归实现的主框架

// 假设按照升序对array数组中[left, right)区间中的元素进行排序
void QuickSort(int[] array, int left, int right) {
    if (right - left <= 1) return;
// 按照基准值对array数组的 [left, right)区间中的元素进行划分
    int div = partion(array, left, right);
// 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right) // 递归排[left, div)
    QuickSort(array, left, div);
// 递归排[div+1, right)
    QuickSort(array, div + 1, right);
}

与二叉树前序遍历规则非常像，在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。

3.Hoare法（方法一）

【图解】

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

【主要代码展示】

/**
     * Hoare法
     * @param array
     * @param left
     * @param right
     * @return
     */
    private static int partitionHoare(int[] array, int left, int right) {
        //这里以最左边的元素为基准元素
        int tmp = array[left];
        //要先记录下来 left 的值，因为在下面操作过程中，left 的值会变
        int i = left;
        while (left < right){

            while (left < right && array[right] >= tmp){
                right--;
            }

            while (left < right && array[left] <= tmp){
                left++;
            }

            //进行交换
            swap(array,left,right);
        }
        //将基准元素交换到中间
        swap(array,i,left);
        //返回此时基准元素的下标
        return left;
    }

【测试这个方法】

public static void testQuickArray(int[] array){
        int[] tmpArray = Arrays.copyOf(array,2 * array.length);
        long startTime = System.currentTimeMillis();
        Sort.quickSort(tmpArray);
        long endTime = System.currentTimeMillis();
        System.out.println("快速排序所用时间：" + (endTime - startTime));
    }

   public static void main(String[] args) {
        System.out.println("给100000个数据");
        int[] array = new int[10_0000];
        inorderArray(array);
//        notInorderArray(array);
//        initArray(array);

        testInsertArray(array);
        testShellArray(array);
        testSelectArray(array);
        testQuickArray(array);

    }

在这里插入图片描述

栈会溢出，可以修改idea里面的配置
在这里插入图片描述

因为这个方法时间复杂度：
* 最好情况下：O(N*logN)
* 最坏情况下：O(N^2) 有序 / 逆序
* 空间复杂度：
* 最好情况下：O(logN)
* 最坏情况下：O(N)
* 稳定性：
* 不稳定的排序

4.挖坑法（方法二）

【图解】

在这里插入图片描述

【主要代码展示】

    /**
     * 挖坑法
     * @param array
     * @param left
     * @param right
     * @return
     */
    public static int partition(int[] array,int left,int right){
        int tmp = array[left];
        while (left < right){

            while (left < right && array[right] >= tmp){
                right--;
            }
            array[left] = array[right];

            while (left < right && array[left] <= tmp){
                left++;
            }
            array[right] = array[left];
        }

        array[left] = tmp;
        return left;
    }

【测试这个方法】

public static void main(String[] args) {
        int[] array = {3,5,2,10,9,8,17};
        Sort.quickSort(array);
        System.out.println(Arrays.toString(array));
    }

在这里插入图片描述

5.前后指针法（方法三）

【写法一】

/**
     * 前后指针法
     */
    private static int partition2(int[] array, int left, int right) {
        int prev = left;
        int cur = left + 1;
        while (cur <= right) {
            if (array[cur] < array[left] && array[++prev] != array[cur]) {
                swap(array, cur, prev);
            }
            cur++;
        }
        swap(array, prev, left);
        return prev;
    }

【写法二】

private static int partition3(int[] array, int left, int right) {
        int d = left + 1;
        int pivot = array[left];
        for (int i = left + 1; i <= right; i++) {
            if (array[i] < pivot) {
                swap(array, i, d);
                d++;
            }
        }
        swap(array, d - 1, left);

        return d - 1;
    }

二、快速排序优化

1.三数取中法选key

private static int middleNum(int[] array, int left,int right){
        //中间位置的下标
        int mid = left + ((right - left) >> 1);
        //怎么拿到这个下标对应的中间数字呢

        if (array[left] < array[right]){
            if (array[mid] < array[left]){
                return left;
            }else if (array[right] < array[mid]){
                return right;
            }else {
                return mid;
            }
        }else {
            if (array[right] > array[mid]){
                return right;
            }else if (array[mid] > array[left]){
                return left;
            }else {
                return mid;
            }
        }
    }

2.递归到小的子区间时，可以考虑使用插入排序

在这里插入图片描述

public static void insertSort2(int[] array,int start,int end) {
        //要求数组不为空
        for (int i = start + 1; i <= end; i++) {
            //将 i 下标的值放入 tmp 中
            int tmp = array[i];
            int j = i - 1;
            for (; j >= start; j--) {
                //j下标的值和i下标的值进行比较
                if (array[j] > tmp) {
                    array[j + 1] = array[j];
                } else {
//                    array[j + 1] = tmp;
                    break;
                }
            }
            array[j + 1] = tmp;
        }
    }

3.快速排序非递归

    /**
     * 快排非递归
     */
    public static void quickSortNor(int[] array){
        Stack<Integer> stack = new Stack<>();
        int left = 0;
        int right = array.length - 1;
        int pivot = partition(array,left,right);
        if (pivot - 1 > left){
            stack.push(left);
            stack.push(pivot - 1);
        }
        if (pivot + 1 < right){
            stack.push(right);
            stack.push(pivot + 1);
        }
        while (!stack.isEmpty()){
            right = stack.pop();
            left = stack.pop();
            pivot = partition(array,left,right);
            if (pivot - 1 > left){
                stack.push(left);
                stack.push(pivot - 1);
            }

            if (pivot + 1 < right){
                stack.push(right);
                stack.push(pivot + 1);
            }
        }
    }

三、完整代码

public static void quickSort(int[] array) {
        //首先要对待排序的元素进行划分
        //找到一个点，使左边比这个点小，右边比这个点大
        //可以以最左边或者最右边的元素作为基准
        //调用下面的方法进行划分
        quick(array, 0, array.length - 1);
    }

    private static void quick(int[] array, int start, int end) {
        if (start >= end) {
            return;
        }

        if ((end - start + 1) <= 19) {
            insertSort2(array, start, end);
        }

        //找基准之前，先对三数取中
        int index = middleNum(array, start, end);
        //找到中间元素下标之后
        //进行交换
        //把中间大的下标和第一个数字交换

        swap(array, index, start);

        //找到划分之后 基准元素的下标
        int pivot = partition(array, start, end);
        //以基准元素为点，又分左右两边
        //类似与二叉树的前序遍历
        quick(array, start, pivot - 1);//左边
        quick(array, pivot + 1, end);//右边
    }

    public static void insertSort2(int[] array, int start, int end) {
        //要求数组不为空
        for (int i = start + 1; i <= end; i++) {
            //将 i 下标的值放入 tmp 中
            int tmp = array[i];
            int j = i - 1;
            for (; j >= start; j--) {
                //j下标的值和i下标的值进行比较
                if (array[j] > tmp) {
                    array[j + 1] = array[j];
                } else {
//                    array[j + 1] = tmp;
                    break;
                }
            }
            array[j + 1] = tmp;
        }
    }

    private static int middleNum(int[] array, int left, int right) {
        //中间位置的下标
        int mid = left + ((right - left) >> 1);
        //怎么拿到这个下标对应的中间数字呢

        if (array[left] < array[right]) {
            if (array[mid] < array[left]) {
                return left;
            } else if (array[right] < array[mid]) {
                return right;
            } else {
                return mid;
            }
        } else {
            if (array[right] > array[mid]) {
                return right;
            } else if (array[mid] > array[left]) {
                return left;
            } else {
                return mid;
            }
        }
    }

    /**
     * Hoare法
     *
     * @param array
     * @param left
     * @param right
     * @return
     */
    private static int partitionHoare(int[] array, int left, int right) {
        //这里以最左边的元素为基准元素
        int tmp = array[left];
        //要先记录下来 left 的值，因为在下面操作过程中，left 的值会变
        int i = left;
        while (left < right) {

            while (left < right && array[right] >= tmp) {
                right--;
            }

            while (left < right && array[left] <= tmp) {
                left++;
            }

            //进行交换
            swap(array, left, right);
        }
        //将基准元素交换到中间
        swap(array, i, left);
        //返回此时基准元素的下标
        return left;
    }


    /**
     * 挖坑法
     *
     * @param array
     * @param left
     * @param right
     * @return
     */
    public static int partition(int[] array, int left, int right) {
        int tmp = array[left];
        while (left < right) {

            while (left < right && array[right] >= tmp) {
                right--;
            }
            if (left >= right) {
                break;
            }
            array[left] = array[right];

            while (left < right && array[left] <= tmp) {
                left++;
            }
            if (left >= right) {
                break;
            }
            array[right] = array[left];
        }

        array[left] = tmp;
        return left;
    }

    /**
     * 前后指针法
     */
    private static int partition2(int[] array, int left, int right) {
        int prev = left;
        int cur = left + 1;
        while (cur <= right) {
            if (array[cur] < array[left] && array[++prev] != array[cur]) {
                swap(array, cur, prev);
            }
            cur++;
        }
        swap(array, prev, left);
        return prev;
    }

    private static int partition3(int[] array, int left, int right) {
        int d = left + 1;
        int pivot = array[left];
        for (int i = left + 1; i <= right; i++) {
            if (array[i] < pivot) {
                swap(array, i, d);
                d++;
            }
        }
        swap(array, d - 1, left);

        return d - 1;
    }

总结

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度： O(N*logN)

在这里插入图片描述

  1. 空间复杂度： O(logN)
  2. 稳定性：不稳定

在这里插入图片描述

在这里插入图片描述

明志学编程-
关注
  • 12
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java数据结构——快速排序
NoBug
03-03 352
1. 快速排序******************** 2. 快速排序的原理************* 3. 快速排序的时间复杂度***** 4. 下一天选择排序*************
数据结构实验——排序子系统
07-31
数据结构实验——排序子系统 本实验报告的主要目的是掌握常用排序方法的基本思想，通过实验加深理解各种排序算法，并了解各种排序方法的优缺点及适用范围。实验内容包括编写直接插入排序、希尔排序、冒泡排序、快速...
【数据结构】排序——快速排序
m0_74091744的博客
07-11 1207
1.快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫。
数据结构——排序——快速排序
qq_38620871的博客
06-15 312
#include"stdafx.h" #include"stdlib.h" #include"math.h" using namespace std; void swap(int k[], int low, int high) { int temp; temp = k[high]; k[high] = k[low]; k[low] = temp; } int Partition(int k[], int low, int high) { int point; point = k[low];.
C++ 数据结构——快速排序
qq_45875966的博客
04-11 118
/* 快速排序 */ #include <iostream> using namespace std; int *data; int Partition(int first,int last) { int i=first,j=last,temp; while (i<j) { while (i<j&&data[i]<=data[j]) j--; //右侧扫描 if(i<j) {
数据结构——快速排序
Alan的博客
05-11 6330
1、排序思路 快速排序（quick sort）是由冒泡排序改进而得得，它的基本思想是在待排序的n个元素中n个元素中任取一个元素（通常取第一个元素）作为基准，把该元素放入适当的位置后，数据序列被此元素划分成两部分。所有关键字比该元素关键字小的放置在前一部分，所有关键字比该元素关键字大的放置在后一部分，并把该元素排在这两部分中间（称该元素归为），这个过程称为一趟快速排序，即一趟划分。   之后对产生的...
数据结构代码运行————快速排序
qq_45744200的博客
10-23 95
【代码】数据结构代码运行————快速排序。
Java数据结构与算法——快速排序
★★光亭★★
03-16 5131
Java数据结构与算法——快速排序
[算法]排序——快速排序（QuickSort）多种实现方式（C语言）
SUICIDEKILL的博客
03-29 3947
快速排序算法实现
【数据结构】排序算法——Lessen1
奋斗的小羊的博客
07-22 2783
排序算法超超超详解
数据结构课程设计五——排序算法综合分析.doc
06-03
数据结构课程设计五——排序算法综合分析 该资源是一个数据结构课程设计的五个部分，主要讲解排序算法的综合分析。该资源涵盖了多种排序算法，包括直接插入排序、希尔排序、快速排序、冒泡排序、堆排序和归并法排序...
华中科技大学数据结构与算法分析实验-内部排序实验报告
04-05
《内部排序算法实践与分析——华中科技大学数据结构与算法实验报告》 内部排序是计算机科学中的重要领域，涉及各种算法的设计与优化。本实验旨在深入理解并掌握常见内部排序算法，包括直接插入排序、冒泡排序、简单...
数据结构课程设计——排序综合
07-10
数据结构课程设计——排序综合 在计算机科学中，排序是数据结构中的一种基本操作。排序算法的选择对程序的效率和正确性有着非常重要的影响。本文通过对随机生成的 20000 个整数进行多种排序方法的实现和对比，探究...
数据结构快排序
09-01
本篇文章将深入探讨一种高效的排序算法——**快速排序**（Quick Sort），并基于给定代码进行解析。 #### 快速排序算法原理 快速排序是一种分而治之的排序算法。它的基本思想是：选择一个基准元素，通过一趟排序将...
【数据结构-前缀哈希】力扣523. 连续的子数组和
sjsjs11的博客
08-05 110
当发现有两个余数相同的key的时候，对他们value作差，如果大于等于二，说明该子段长度大于等于二，这时候就找到了一个好的子数组，返回true，如果到最后都没有找到这样一个好的子数组，返回false。，其中 m 是数组 nums 的长度。解释：[23, 2, 6, 4, 7] 是大小为 5 的子数组，并且和为 42。输入：nums = [23,2,6,4,7], k = 13。输入：nums = [23,2,4,6,7], k = 6。输入：nums = [23,2,6,4,7], k = 6。
【数据结构】——链式二叉树
2402_82668782的博客
08-02 906
1>二叉树的结构体 包含了数据和指向左右子树的指针}BTNode;<2>二叉树结点的创建<3>二叉树的创建Tip：二叉树是递归定义的，都可以单独看作 根、左子树、右子树。
数据结构：链表经典算法OJ题
2401_86551514的博客
08-04 600
在了解了链表的相关知识后，我们还需要一些题目进行练习加深对链表这方面知识的理解，也可以用来检测链表这块学的的怎么样，废话不多说，开始上手。
数据结构：栈（含源码）
最新发布
2401_86551514的博客
08-05 237
先判断容量是否有足够的空间让数据入栈，在第一次入栈是先给定4个空间，后面每次不够时就将空间数乘以2， 还有一个判断是否开辟成功（这个可以不写，一般都会开辟成功）。栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底，栈中的数据元素遵守后进先出的原则。我们在创建栈时，一般是创建支持动态增长的栈，定长的静态栈不实用。出栈非常的简单，只要将top数减少一个就行了，相当于是下一次入栈是直接把这个数据修改掉，就算没修改，打印时也不影响。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值