（一）数据结构——排序

于 2022-06-04 12:52:25 发布
阅读量499 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 排序算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjj1910066023/article/details/125118585
版权
本文深入探讨了排序算法，包括插入排序、快速排序、选择排序、堆排序、归并排序等，详细解析了它们的时间复杂度和空间复杂度。此外，还介绍了计数排序、基数排序和桶排序等特殊排序方法。对于每种排序算法，提供了具体的Java实现，并分析了其最佳、最坏及平均情况下的性能。
摘要由CSDN通过智能技术生成

文章目录

一、时间复杂度

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

二、空间复杂度

在这里插入图片描述

三、排序算法

在这里插入图片描述

1.插入排序（熟悉）

在这里插入图片描述

public class Solution {

    // 插入排序：稳定排序，在接近有序的情况下，表现优异

    public int[] sortArray(int[] nums) {
        int len = nums.length;
        // 循环不变量：将 nums[i] 插入到区间 [0, i) 使之成为有序数组
        for (int i = 1; i < len; i++) {
            // 先暂存这个元素，然后之前元素逐个后移，留出空位
            int temp = nums[i];
            int j = i;
            // 注意边界 j > 0
            while (j > 0 && nums[j - 1] > temp) {
                nums[j] = nums[j - 1];
                j--;
            }
            nums[j] = temp;
        }
        return nums;
    }
}


输入：nums = [5,2,3,1]
输出：[1,2,3,5]
  • 最好情况下，即待排序序列已按关键字有序，每趟操作只需 1 次比较 0 次移动。
  • 最坏情况下，即待排序序列按关键字逆序排序，这时在第 j 趟操作中，为插入元素需要同前面的 j 个元素进行 j 次关键字比较，移动元素的次数为 j+1 次。
  • 平均情况下：即在第 j 趟操作中，插入记录大约需要同前面的 j/2 个元素进行关键字比较，移动记录的次数为 j/2+1 次。

2.希尔排序(不建议多花时间了解）

在这里插入图片描述

3.冒泡排序(了解）

在这里插入图片描述

public class Solution {
    public int[] sortArray(int[] nums) {
        int len = nums.length;
        for (int i = len - 1; i >= 0; i--) {
            // 先默认数组是有序的，只要发生一次交换，就必须进行下一轮比较，
            // 如果在内层循环中，都没有执行一次交换操作，说明此时数组已经是升序数组
            boolean sorted = true;
            for (int j = 0; j < i; j++) {
                if (nums[j] > nums[j + 1]) {
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
        return nums;
    }
}
  • 假设待排序的元素个数为 n，则总共要进行 n-1 趟排序，对 j 个元素的子序列进行一趟起泡排序需要进行 j-1 次关键字比较。

4.快速排序(重要）

在这里插入图片描述

  • 最坏情况是每次进行划分时，在所得到的两个子序列中有一个子序列为空。
  • 最好情况是在每次划分时，都将序列一分为二，正好在序列中间将序列分成长度相等的两个子序列。
class Solution {
    //利用快速排序解决
    public int[] sortArray(int[] nums) {
        //定义一个左指针，指向数组元素的第一个元素
        int left = 0;
        //定义一个右指针，指向数组元素的最后一个
        int right = nums.length-1;
        //定义一个快速排序的方法
        return quickSort(nums,left,right);
    }
    public int[] quickSort(int[] nums, int left,int right){
        //如果左指针大于右指针，怎退出循环
        if(left > right){
            return null;
        }
        //定一个基数，指向数组的最左边的元素
        int base = nums[left];
         //定义一个左指针，指向数组元素的第一个元素
        int i = left;
        //定义一个右指针，指向数组元素的最后一个
        int j = right;
        //当左右指针不相等时，就继续移动左右指针
        while(i != j){
            //从右往左遍历，当右指针指向的元素大于等于基数时，j--。右指针持续向左移动
            while(nums[j]>=base && i < j){
                j--;
            }
            //从左往右遍历，当左指针指向的元素小于等于基数时，i++。左指针持续向右移动
            while(nums[i]<=base && i < j){
                i++;
            }
            //当左右两个指针停下来时，交换两个元素
            swap(nums, i, j);

        }
        //当左右指针相遇时，将左右指针同时指向的元素和基数进行交换。
        swap(nums,i,left);//这个看着可能会变扭，等同于小面两行代码。
        //不过这下面的两行的代码的顺序不能相反，否则导致结果，都为第一个基数。
        //首先把基数要填入的位置空出来，然后在将基数填入。
        // nums[left] = nums[i];
        // nums[i] = base;
        quickSort(nums,left, i-1);
        quickSort(nums,i+1,right);
        return nums;
    }
    public void swap(int[] nums,int left, int right){
        int temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
    }
}

5.选择排序(了解）

在这里插入图片描述

import java.util.Arrays;

public class Solution {

    // 选择排序：每一轮选择最小元素交换到未排定部分的开头

    public int[] sortArray(int[] nums) {
        int len = nums.length;
        // 循环不变量：[0, i) 有序，且该区间里所有元素就是最终排定的样子
        for (int i = 0; i < len - 1; i++) {
            // 选择区间 [i, len - 1] 里最小的元素的索引，交换到下标 i
            int minIndex = i;
            for (int j = i + 1; j < len; j++) {
                if (nums[j] < nums[minIndex]) {
                    minIndex = j;
                }
            }
            swap(nums, i, minIndex);
        }
        return nums;
    }

    private void swap(int[] nums, int index1, int index2) {
        int temp = nums[index1];
        nums[index1] = nums[index2];
        nums[index2] = temp;
    }

    public static void main(String[] args) {
        int[] nums = {5, 2, 3, 1};
        Solution solution = new Solution();
        int[] res = solution.sortArray(nums);
        System.out.println(Arrays.toString(res));
    }
}
  • 在简单选择排序中，所需移动元素的次数较少，在待排序序列已经有序的情况下，简单选择排序不需要移动元素，在最坏的情况下，即待排序序列本身是逆序时，则移动元素的次数为 3(n-1)。然而无论简单选择排序过程中移动元素的次数是多少，在任何情况下，简单选择排序都需要进行n(n-1)/2 次比较操作，因此简单选择排序的时间复杂度为Ο(n2)。

6.堆排序(堆很重要，堆排序根据个人情况掌握）

在这里插入图片描述

class Solution{
    
public int[] sortArray(int[] nums) {
        heapSort(nums);
        return nums;
    }

    /**
     * 堆排序(宇宙无敌的JAVA)
     *  第一步: 构建大顶堆
     *  第二步: 交换堆点元素(堆点元素与当前处理的二叉树最后一个元素交换)
     *  第三步: 去除二叉树最后一个节点, 对二叉树根节点堆化(heapify)
     *  第四步: 重复第二、第三步直至结束
     */
    private void heapSort(int[] nums) {
        int len = nums.length;
        //第一步: 构建大顶堆
        buildMaxHead(nums, len);
        //第四步: 重复第二、第三步直至结束
        for (int i = len - 1; i >= 1; i--) {
            //第二步: 交换堆点元素(堆点元素与当前处理的二叉树最后一个元素交换)
            swap(nums, i, 0);
            //第三步: 去除二叉树最后一个节点, 对二叉树根节点堆化(heapify)
            //  元素少于两个没有必要再处理, 这里不特殊判断处理
            heapify(nums, i, 0);
        }
    }

    /**
     * 构建大顶堆
     */
    private void buildMaxHead(int[] nums, int len) {
        //从倒数第二层数的节点开始, 一直到二叉树根节点, 进行堆化(heapify)
        //  求取最后一个节点的父节点, 父节点索引为 int parentIndex = (i - 1) / 2
        int lastNodeIndex = ((len - 1) - 1) / 2;
        for (int i = lastNodeIndex; i >= 0; i--) {
            heapify(nums, len, i);
        }
    }

    private void heapify(int[] nums, int len, int cur) {
        if (cur >= len){
            return;
        }
        //第一个子节点的索引位置 int c1 = 2 * i + 1
        //第二个子节点的索引位置 int c2 = 2 * i + 2
        int c1 = 2 * cur + 1;
        int c2 = 2 * cur + 2;
        //求最大值的索引
        int maxIndex = cur;
        if (c1 < len && nums[c1] > nums[maxIndex]){
            maxIndex = c1;
        }
        if (c2 < len && nums[c2] > nums[maxIndex]){
            maxIndex = c2;
        }
        //当前节点cur不是该堆的最大值, 交换元素值, 并递归被交换点进行堆化(heapify)
        if (cur != maxIndex){
            swap(nums, cur, maxIndex);
            heapify(nums, len, maxIndex);
        }
    }

    /**
     * 交换元素值
     */
    private void swap(int[] nums, int x, int y) {
        int temp = nums[x];
        nums[x] = nums[y];
        nums[y] = temp;
    }
}

7.归并排序(重点）

在这里插入图片描述

public class Solution {
    /**
     * 列表大小等于或小于该大小，将优先于 mergeSort 使用插入排序
     */
    private static final int INSERTION_SORT_THRESHOLD = 7;

    public int[] sortArray(int[] nums) {
        int len = nums.length;
        int[] temp = new int[len];
        mergeSort(nums, 0, len - 1, temp);
        return nums;
    }

    /**
     * 对数组 nums 的子区间 [left, right] 进行归并排序
     * @param temp  用于合并两个有序数组的辅助数组，全局使用一份，避免多次创建和销毁
     */
    private void mergeSort(int[] nums, int left, int right, int[] temp) {
        // 小区间使用插入排序
        if (right - left <= INSERTION_SORT_THRESHOLD) {
            insertionSort(nums, left, right);
            return;
        }

        int mid = left + (right - left) / 2;
        // Java 里有更优的写法，在 left 和 right 都是大整数时，即使溢出，结论依然正确
        // int mid = (left + right) >>> 1;

        mergeSort(nums, left, mid, temp);
        mergeSort(nums, mid + 1, right, temp);
        // 如果数组的这个子区间本身有序，无需合并
        if (nums[mid] <= nums[mid + 1]) {
            return;
        }
        mergeOfTwoSortedArray(nums, left, mid, right, temp);
    }

    /**
     * 对数组 arr 的子区间 [left, right] 使用插入排序
     */
    private void insertionSort(int[] arr, int left, int right) {
        for (int i = left + 1; i <= right; i++) {
            int temp = arr[i];
            int j = i;
            while (j > left && arr[j - 1] > temp) {
                arr[j] = arr[j - 1];
                j--;
            }
            arr[j] = temp;
        }
    }

    /**
     * 合并两个有序数组：先把值复制到临时数组，再合并回去
     * @param mid   [left, mid] 有序，[mid + 1, right] 有序
     * @param temp  全局使用的临时数组
     */
    private void mergeOfTwoSortedArray(int[] nums, int left, int mid, int right, int[] temp) {
        System.arraycopy(nums, left, temp, left, right + 1 - left);

        int i = left;
        int j = mid + 1;

        for (int k = left; k <= right; k++) {
            if (i == mid + 1) {
                nums[k] = temp[j];
                j++;
            } else if (j == right + 1) {
                nums[k] = temp[i];
                i++;
            } else if (temp[i] <= temp[j]) {
                // 注意写成 < 就丢失了稳定性（相同元素原来靠前的排序以后依然靠前）
                nums[k] = temp[i];
                i++;
            } else {
                // temp[i] > temp[j]
                nums[k] = temp[j];
                j++;
            }
        }
    }
}

8.计数排序(了解）

在这里插入图片描述

public class Solution {
    private static final int OFFSET = 50000;

    public int[] sortArray(int[] nums) {
        int len = nums.length;
        // 由于 -50000 <= A[i] <= 50000
        // 因此"桶" 的大小为 50000 - (-50000) = 10_0000
        // 并且设置偏移 OFFSET = 50000，目的是让每一个数都能够大于等于 0
        // 这样就可以作为 count 数组的下标，查询这个数的计数
        int size = 10_0000;

        // 计数数组
        int[] count = new int[size];
        // 计算计数数组
        for (int num : nums) {
            count[num + OFFSET]++;
        }

        // 把 count 数组变成前缀和数组
        for (int i = 1; i < size; i++) {
            count[i] += count[i - 1];
        }

        // 先把原始数组赋值到一个临时数组里，然后回写数据
        int[] temp = new int[len];
        System.arraycopy(nums, 0, temp, 0, len);

        // 为了保证稳定性，从后向前赋值
        for (int i = len - 1; i >= 0; i--) {
            int index = count[temp[i] + OFFSET] - 1;
            nums[index] = temp[i];
            count[temp[i] + OFFSET]--;
        }
        return nums;
    }
}

9.基数排序(了解）

在这里插入图片描述

public class Solution {
    private static final int OFFSET = 50000;

    public int[] sortArray(int[] nums) {
        int len = nums.length;

        // 预处理，让所有的数都大于等于 0，这样才可以使用基数排序
        for (int i = 0; i < len; i++) {
            nums[i] += OFFSET;
        }

        // 第 1 步：找出最大的数字
        int max = nums[0];
        for (int num : nums) {
            if (num > max) {
                max = num;
            }
        }

        // 第 2 步：计算出最大的数字有几位，这个数值决定了我们要将整个数组看几遍
        int maxLen = getMaxLen(max);

        // 计数排序需要使用的计数数组和临时数组
        int[] count = new int[10];
        int[] temp = new int[len];

        // 表征关键字的量：除数
        // 1 表示按照个位关键字排序
        // 10 表示按照十位关键字排序
        // 100 表示按照百位关键字排序
        // 1000 表示按照千位关键字排序
        int divisor = 1;
        // 有几位数，外层循环就得执行几次
        for (int i = 0; i < maxLen; i++) {

            // 每一步都使用计数排序，保证排序结果是稳定的
            // 这一步需要额外空间保存结果集，因此把结果保存在 temp 中
            countingSort(nums, temp, divisor, len, count);

            // 交换 nums 和 temp 的引用，下一轮还是按照 nums 做计数排序
            int[] t = nums;
            nums = temp;
            temp = t;

            // divisor 自增，表示采用低位优先的基数排序
            divisor *= 10;
        }

        int[] res = new int[len];
        for (int i = 0; i < len; i++) {
            res[i] = nums[i] - OFFSET;
        }
        return res;
    }

    private void countingSort(int[] nums, int[] res, int divisor, int len, int[] count) {
        // 1、计算计数数组
        for (int i = 0; i < len; i++) {
            // 计算数位上的数是几，先取个位，再十位、百位
            int remainder = (nums[i] / divisor) % 10;
            count[remainder]++;
        }

        // 2、变成前缀和数组
        for (int i = 1; i < 10; i++) {
            count[i] += count[i - 1];
        }

        // 3、从后向前赋值
        for (int i = len - 1; i >= 0; i--) {
            int remainder = (nums[i] / divisor) % 10;
            int index = count[remainder] - 1;
            res[index] = nums[i];
            count[remainder]--;
        }

        // 4、count 数组需要设置为 0 ，以免干扰下一次排序使用
        for (int i = 0; i < 10; i++) {
            count[i] = 0;
        }
    }

    /**
     * 获取一个整数的最大位数
     *
     * @param num
     * @return
     */
    private int getMaxLen(int num) {
        int maxLen = 0;
        while (num > 0) {
            num /= 10;
            maxLen++;
        }
        return maxLen;
    }
}

10.桶排序（了解）

基本思路：一个坑一个萝卜，也可以一个坑多个萝卜，对每个坑排序，再拿出来，整体就有序。

【数据结构】什么是内排序、外排序？内排序详细介绍
四季轮换叶，一路招摇胜
10-08 6841
内部排序是指待排序列数据记录完全存放在内存中所进行的排序过程。 外部排序在排序过程中还需要访问外部存储器的排序。
排序算法之冒泡排序
weixin_45166406的博客
03-02 302
思路：两两相邻的元素，如果顺序反序，那么就将他们交换位置 还是通过序列来看（本次我们来个从大到小排序） 12，35，99，18，76 首先比较第一个和第二个（12和35），逆序，换 35，12，99，18，76 比较第二个和第三个（12和99），逆序，换 35，99，12，18，76 比较第三个和第四个（12和18），逆序，换 35，99，18，12，76 最后比较第四个和第五个（12，76），逆序，换 35，99，18，76，12 （第一趟结束） 至...
排序算法总结
wj903829182的专栏
07-21 1410
c，数据结构，排序，选择排序，插入排序
2020-12-21
yuankeLi的博客
12-21 563
数据结构——排序总结 一、插入排序 主要思路： ​ 将待排序子序列中的一个元素按其排序码的大小插入到已经排好序的有序子序列中的适当位置，使得有序子序列扩大一个元素。 1、直接插入排序 思路：将数组a[n]中待排序的n个元素看成一个有序表和一个无序表，开始时有序表只包含一个元素a[0],无序表中包含n-1个元素a[1]~a[n-1]。在排序过程中，无序表中的每个表头元素退出无序表插入到有序表，与有序表中的元素从后向前进行比较，将该元素插入到有序表中的合适位置，使有序表成为新的有序表，这样经过n-1次退出和插入
排序算法——快速排序
weixin_45732589的博客
04-01 323
快速排序 1. 快排的思想 先在数据中找一个基准数据 ： 找待排序数据序列的第一个， 随机数， 三位数取中 将数据按照基准数据分成两部分，前一段都比基准小，后一段都比基准大。 按照同样的思想分别处理前一段和后一段数据。 2.代码的实现（递归版） 数据段为start到end之间的数据。先将基准数据(start位置)保存到tmp中，i=start，j = end。 在i<j的时候，重复执行以下两个过程。 通过j从后往前找第一个比基准数据小的数据，找到后就将j位置的值赋值到i位置 通过i从前向后.
排序算法之快速排序c语言（三）
m0_52261881的博客
07-22 572
快速排序法—（几乎最优的排序算法） 前言：快速排序是一种典型的分而治之算法，并且只需要非常少的时间就能完成排序操作。在冒泡排序中https://blog.csdn.net/m0_52261881/article/details/118654312 ，互换两个相邻元素时只能消除一个逆序，而快速排序方法中的一次交换可能消除多个逆序，因此大大加快了排序的速度。是对冒泡排序改进的一种算法。 算法思想： 从待排序序列中选取一个数，可以随机取，但一般是取第一个，称为基准数，设为K,然后将小于K的数放到左边，比K大的排
数据结构——归并排序
06-17
《数据结构》严蔚敏版是计算机科学的经典教材，其中对归并排序有深入的阐述。下面我们将详细探讨归并排序的原理、实现方式以及其在实际应用中的优势。 一、归并排序的基本概念 归并排序的核心思想是将大问题分解为...
数据结构实验——排序子系统
07-31
数据结构实验——排序子系统 本实验报告的主要目的是掌握常用排序方法的基本思想，通过实验加深理解各种排序算法，并了解各种排序方法的优缺点及适用范围。实验内容包括编写直接插入排序、希尔排序、冒泡排序、快速...
数据结构——堆排序.h
09-11
数据结构——堆排序 数据结构——堆排序 数据结构——堆排序 数据结构——堆排序 数据结构——堆排序 数据结构——堆排序
数据结构——快速排序.h
09-11
数据结构——快速排序 数据结构——快速排序 数据结构——快速排序 数据结构——快速排序 数据结构——快速排序
数据结构课程设计五——排序算法综合分析.doc
06-03
数据结构课程设计五——排序算法综合分析 该资源是一个数据结构课程设计的五个部分，主要讲解排序算法的综合分析。该资源涵盖了多种排序算法，包括直接插入排序、希尔排序、快速排序、冒泡排序、堆排序和归并法排序...
十大排序算法（绝对口语化的概念理解）
qq_53443536的博客
07-27 381
本篇文章，介绍了冒泡排序、快速排序、直接选择排序、希尔排序、简单选择排序、堆排序、归并排序、基数排序。绝不是简单的概念堆积，是博主对于概念的理解，口语化转述出来的。
排序算法-选择类排序
LaL15281183992的博客
01-04 628
选择排序的算法思想：重待排序的元素序列中选择最小（最大）的元素，将其放入在已排序序列的最前(最末），其余的元素构成新的待排序列。依次类推，直到待排序元素序列中没有待排元素。选择排序主要有两种：简单选择排序和堆排序。接下来我们来分别介绍一下这两种排序算法。
各种排序最好最坏的比较次数
热门推荐
u013176681的专栏
12-07 4万+
都不知道怎么回答，各种排序说的也太多了，这里讲几种简单的吧，希望对你有帮助！ 比如n个顺序存储元素进行排序，a[0]做“哨兵”（即a[0]不存数据，而是用作辅存空间使用）的情况 1 直接插入排序：比较次数 最少n-1次；最多(n-1)(n+2)/2 移动次数 最少0； 最多(n-1)(n+4)/2
八大排序的特点以及在何种情况下哪种排序方法有优势
qq_42752746的博客
08-13 3931
排序方法/特点 稳定性 时间复杂度   冒泡排序 稳定 O(n^2)   直接插入排序 稳定 O(n^2)   希尔排序 不稳定 O（n^1.3）   选择排序 不稳定 O(n^2)   快速排序 不稳定  O(nlog2 n)   堆排序 不稳定 O(n...
排序选择题
正在进行时
05-11 3万+
一、 单项选择题（共71题） 对n个元素的序列进行冒泡排序时，最少的比较次数是（ ）。 A. n B. n-1 C. n/2 D. log2n 答案：B若一个元素序列基本有序，则选用（ ）方法较快。 A. 直接插入排序 B. 简单选择排序 C. 堆排序 D. 快速排序 答案：A在对n个元素进行冒泡排序的过程中，第一趟排序至多需要进行（ ）对相邻元素之间的交换。 A. n B. n
已知有7个待排序的元素，它们的关键字序列为(47, 56, 29, 16, 92, 33, 20)，编写一个程序，用如下方法对其进行升序排序，要求显示每趟排序的结果：直接插入排序；希尔排序；冒泡排序
m0_62143782的博客
11-27 2269
#include<stdio.h> #include<string> #include<stdlib.h> const int MAXSIZE=100; typedef int KeyType; typedef int ElemType; typedef struct { KeyType key; ElemType data; }SqType; void InsertSort(SqType R[],int n) { int i,j; SqTy...
数据结构-排序算法
zhangqin__的博客
08-12 218
一：直接插入排序 算法思想：把数组a[n]中待排序的n个元素看作一个有序表和一个无序表。 （1）开始时有序表只包含一个元素a[0]，无序表中包含n-1个元素a[1]…a[n-1]； （2）排序过程中每次从无序表中退出第一个元素，把它插入有序表的适当位置，使之成为新的有序表，元素个数加1。 （3）经过n-1次插入后，无序表变成空表，有序表包含了n个元素，排序完毕。 排序示例： 原始序列：（4...
元素序列几个常用排序算法：一
weixin_34319640的博客
05-04 588
在改章节中,我们主要绍介元素序列的内容,自我感觉有个不错的建议和大家分享下     一、交换排序     1.冒泡排序：     冒泡排序的想思就是每次对指定区间行进历遍的同时，较比相邻元素，如果相邻元素为逆序则交换相邻元素，如果位正序则不作任何作操，这样如果按从小到大的次序历遍数组标下，那么一次历遍以后，全部序列中的最小数或者最大数就“下沉”到数组底部了，反之，如果从大到小历遍数组小标，那...
数据结构——排序算法
最新发布
12-21
数据结构中的排序算法是指一种将一串数据按照特定顺序（通常是升序或降序）排列的方法。常见的排序算法有多种，每种都有其特点和适用场景： 1. **冒泡排序**（Bubble Sort）：简单直观，通过不断交换相邻元素使得较...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值
>