数据结构（初始算法篇）-排序算法

最新推荐文章于 2022-01-26 13:26:32 发布
最新推荐文章于 2022-01-26 13:26:32 发布
阅读量664 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 算法 排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mmklo/article/details/122135297
版权

数组排序算法

数组之常见的排序算法

排序：就是把一个无序的序列通过某种方式变成一个有序序列

冒泡排序

排序原理：

数组元素两两比较，交换位置，大元素往后放，那么通过一轮比较之后，最大数的元素，就会出现在最大索引处。

冒泡排序是一种比较简单的排序算法，它循环走过需要排序的元素，依次比较相邻的两个元素，如果顺序错误就交换，直至没有元素交换，完成排序。

若对n个人进行排序，我们需要n-1次比较，所以第k次比较需要进行n-k次比较。排序算法通过以数据对象的两两比较作为关键，所以可以得出，冒泡排序需要进行的

比较次数为：(n-1) + (n-2) + … + 1 = n*(n-1) / 2，因此冒泡排序的时间复杂度为O(n^2)。

算法简介:

   1.比较相邻的元素，前一个比后一个大（或者前一个比后一个小）调换位置

   2.每一对相邻的元素进行重复的工作，从开始对一直到结尾对，这步完成后，结尾为做大或最小的数.

   3.针对除了最后一个元素重复进行上面的步骤。

   4.重复1-3步骤直到完成排序

动画演示：

在这里插入图片描述

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {24, 34, 1, 80, 23, 13, 57, 4};
        System.out.println("排序前:"+Arrays.toString(arr));

        int[] ints = PerfectSort();
        System.out.println("排序后:"+Arrays.toString(ints));
    }

    //优化
    public  static  int[] PerfectSort(){
        int[] arr = {24, 34, 1, 80, 23, 13, 57, 4};
        for (int j = 0; j < arr.length - 1 ; j++) {
            for (int i = 0; i < arr.length - 1-j; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp; //设定一个中间变量，存放数组元素的第一个元素
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }

        }
        return arr;
    }
}

排序前:[24, 34, 1, 80, 23, 13, 57, 4]
排序后:[1, 4, 13, 23, 24, 34, 57, 80]

选择排序

排序原理：

从0索引开始，依次和后面的元素进行比较，小的元素往前放，经过一论比较之后，最小的元素出现在最小索引处。

选择排序是一种简单直观的排序算法，工作原理为：在未排序的序列中找出最小(大)元素与第一个位置的元素交换位置

注意选择排序与冒泡排序的区别：冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；而选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。

然后在剩下的元素中再找最小(大)元素与第二个元素的位置交换，依此类推，直到所有元素排序排序完成。根据上述描述，一共进行n-1趟比较后，就能完成整个排队过程。我们可以知道，第k趟比较需要进行的数组元素的两两比较的次数为n-k次，所以共需要的比较次数为n*(n-1) / 2，因此选择排序算法的时间复杂度与冒泡排序一样，也为O(n^2)。

算法简介：

 1.初始状态：序列为无序状态。

 2.第1次排序：从n个元素中找出最小(大)元素与第1个记录交换

 3.第2次排序：从n-1个元素中找出最小(大)元素与第2个记录交换

 4.第i次排序：从n-i+1个元素中找出最小(大)元素与第i个记录交换

5.以此类推直到排序完成

动画演示：
在这里插入图片描述

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {24, 69, 60, 45, 13};
        System.out.println("排序前：" + Arrays.toString(arr));
      
        PerfectSelectSort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
    }

    public static void PerfectSelectSort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 1+i; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int t = arr[i];
                    arr[i] = arr[j];
                    arr[j] = t;
                }
            }
        }
    }
}

排序前：[24, 69, 60, 45, 13]
排序后：[13, 24, 45, 60, 69]

插入排序

排序原理

直接插入排序，是一种最简单的排序方法，他基本的操作是将一个记录插入到长度为m的有序表中，使之仍保持有序。
例如：
49，38，69，57，79，13，47 原始数据



[49],38,65,97,76,13,27 从1索引开始插入

[38,49],65,97,76,13,27

[38,49,65],97,76,13,27

[38,49,65,97],76,13,27

[38,49,65,76,97],13,27

[13,27,38,49,65,76,97],27

[13,27,38,49,65,76,97]

public class DirectInsertionSort {
    public static void main(String[] args) {
        //从1索引处，将一个元素插入到该索引处，使之成为一个有序的序列
        int[] arr = {49, 38, 65, 97, 76, 13, 27};
        //外层循环，定义轮次
//        for (int i = 1; i < arr.length; i++) {
//            //里层循环，进行插入比较
//            int j = 1;
//            while (j > 0 && arr[j] < arr[j - 1]) {
//                //交换
//                int t = arr[j];
//                arr[j] = arr[j - 1];
//                arr[j - 1] = t;
//                j--;
//            }
//        }
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                swapValue(arr,j,j-1);
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

    public static void swapValue(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

[13, 27, 38, 49, 65, 76, 97]

希尔排序

排序思想

希尔排序:又称为减小增量排序，是对插入排序的优化，可以理解为增量为1的直接插入排序

基本思路：先将原表按照增量ht分组，每个子文件按照直接插入法排序。同样，用下一个增量ht/2将文件再分为子文件，在直接插入排序。知道ht = 1整个文件排好序。

关键：选择合适的增量

希尔排序算法：可以通过三重循环实现

动画演示
在这里插入图片描述

public class HillSort {
    public static void main(String[] args) {
        int[] arr = {45, 23, 34, 12, 3, 78, 32};
        /*
        第一轮排序
        * 45,23,34,12,3,78,32
        * [45,3]  换
        * 3,23,34,12,45,78,32
        * [23,78] 不换
        * 3,23,32,12,45,78,34
        * [32,34]  换
        * [3, 23, 32, 12, 45, 78, 34]
        * */
        perfectHillSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void perfectHillSort(int[] arr){
        for (int h = (arr.length/2); h >0 ; h/=2) {  // 计算间隔的元素数：使用数组的长度一半
            for (int i = h; i < arr.length; i++) {
                for (int j = i; j > h-1; j-=h) {
                    if (arr[j] < arr[j - h]) {
                        swapValue(arr,j,j-h);
                    }
                }
            }
        }
    }
}

克努特计算间隔数

public static void perfectHillSort(int[] arr){
        // 计算间隔的元素数：使用克努特序列
        int jiange = 1;
        while (jiange <= arr.length / 3) {
            jiange = jiange*3+1;
        }

        for (int h = jiange; h >0 ; h=(h-1)/3) { // 计算间隔的元素数：使用数组的长度一半
            for (int i = h; i < arr.length; i++) {
                for (int j = i; j > h-1; j-=h) {
                    if (arr[j] < arr[j - h]) {
                        swapValue(arr,j,j-h);
                    }
                }
            }
        }
    }

快速排序

快速排序的思想

分治法:比大小，再分区

1.从数组中取出一个数，作为基准数。

2.分区:将比这个数大或等于的数全放到他的右边，小于他的数
全放到他的左边。

3.再对左右区间重复第二步，直到各区间只有一个数。

动画演示
在这里插入图片描述

代码展示

public class QuickSortUtils {
    public static void quickSort(int[] arr, int start, int end) {
        //找出分左右两区的索引位置，然后对左右两边进行递归调用
        if (start < end) {
            int index = getindex(arr, start, end);
            quickSort(arr, start, index - 1); // 左边分区
            quickSort(arr, index + 1, start); // 右边分区
        }
    }

    public static int getindex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        int x = arr[i];

        while (i < j) {
            //从后往前找
            while (i < j && arr[j] >= x) {
                j--;
            }
            if (i < j) {
                arr[i] = arr[j];
                i++;
            }
            //从前往后找
            while (i < j && arr[i] < x) {
                i++;
            }
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }
        }
        arr[i] = x; //把基准数填到最后一个坑中
        return i;
    }
}

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {10,3,5,6,0,100,45,24,8};
        QuickSortUtils.quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}

[0, 3, 5, 6, 8, 10, 45, 24, 100]

归并排序

排序思想

归并排序(Merge Sort)就是利用归并的思想实现排序的方
法。
它的原理是假设初始序列有N个记录，则可以看成是N个
有序的子序列，每个子序列的长度为1，然后两两归并，
得到N/2个长度为2或1的有序子序列，再两两归并…
如此重复，直至得到一个长度为N的有序序列为止，这种
排序方法称为2路归并排序。

动图演示
在这里插入图片描述

代码演示 递归算法

public class MergeSort {
    public static void main(String[] args) {
        //原始数组
        int[] arr = {2,3,4,1};
        mergeSort(arr);
        //输出
        System.out.println(Arrays.toString(arr));
    }
    private static void mergeSort(int[] array) {
        sort(array,0,array.length-1);
    }

    private static void sort(int[] array, int start, int end) {
        if(start < end) {
            int mid = (start+end)/2;
            sort(array,start,mid);
            sort(array,mid+1,end);
            merge(array,start,mid,end);
        }
    }

    private static void merge(int[] array, int start, int mid, int end) {
        //定义两个指针
        int i = start;
        int j = mid+1;
        //定义一个临时数组和数组的指针
        int[] temp = new int[end-start+1];
        int index = 0;

        while (i <= mid && j <= end) {
            if(array[i] < array[j]) {
                temp[index++] = array[i++];
            } else {
                temp[index++] = array[j++];
            }
        }
        while (i <= mid) {
            temp[index++] = array[i++];
        }
        while (j <= end) {
            temp[index++] = array[j++];
        }
        for (int k = 0; k < index; k++) {
            array[start++] = temp[k];
        }
    }
}

基数排序

排序原理

基数排序时根据基数不同 将不同的数分配到不同的桶中,(最低位优先)基数排序先对根据数列的个位数 将其放入0-9的二维数组中 然后以此对十位数 百位数等进行相同操作 最后得到一个有序数列,当然最高位优先其思想也是一样

动图演示
在这里插入图片描述

public class BaseSort {
    public static void main(String[] args) {
        int[] arr = {6, 10, 25, 80, 612, 8, 12, 15, 9, 6, 7};
        radixSort(arr);
    }

    public static void radixSort(int[] arr) {

        /* 创建一个10*arr.length的二维数组 */
        int[][] duck = new int[10][arr.length];

        /* 先获取最大值 */
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = (int) (arr[i] + 1);
            }
        }

        for (int i = 1; max > 0; i *= 10) {
            /* 记录每个桶的下标 */
            int[] count = new int[10];

            for (int j = 0; j < arr.length; j++) {
                int t = (arr[j] / i) % 10;
                duck[t][count[t]++] = arr[j];
            }
            /* 将桶中的数放回原数组 等待下一位数的排序 */
            for (int j = 0, c = 0; j < 10; j++) {
                for (int k = 0; k < count[j]; k++) {
                    arr[c++] = duck[j][k];
                }
            }
            max /= i;
        }
        System.out.println(Arrays.toString(arr));
    }
}

[6, 6, 7, 8, 9, 10, 12, 15, 25, 80, 612]

堆排序

排序原理

堆排序是利用堆这种数据结构而设计的一种排序算法， 堆排
序是一种选择排序

堆排序的基本思想是:

  1. 将待排序序列构造成一个大顶堆， 此时，整个序列的最大值就是堆顶的根节点。

  2. 将其与末尾元素进行交换，此时末尾就为最大值。

  3. 然后将剩余n-1个元素重新构造成一一个堆 ，这样会得到n个元素的次小值。

  4. 如此反复执行，便能得到一个有序序列了.

在这里插入图片描述

动图展示

在这里插入图片描述

代码展示

public class HeapSort {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {1, 0, 6, 7, 2, 3, 4};
        //调成大顶堆
        toMaxheap(arr, arr.length, 1);
        //我们定义要调整的位置
        int startIndex = (arr.length - 1) / 2;
        //循环开始调整
        for (int i = startIndex; i >= 0; i--) {
            toMaxheap(arr, arr.length, i);
        }

        //经过以上操作之后，已经把数组变成了一个大顶堆，把元素和最后一个元素进行调整
        for (int i = arr.length - 1; i > 0; i--) {
            //调换
            int t = arr[0];
            arr[0] = arr[i];
            arr[i] = t;
            //换完之后，再把剩余元素i调成大顶堆
            toMaxheap(arr,i,0);
        }
        System.out.println(Arrays.toString(arr));
    }

    /**
     * @param arr   要排序的数组
     * @param size  调整的元素个数
     * @param index 从哪里开始调
     */
    private static void toMaxheap(int[] arr, int size, int index) {
        //获取钟左右子节点的索引
        int leftIndexNode = index * 2 + 1;
        int rightIndexNode = index * 2 + 2;
        //查找最大节点对应的索引
        int maxIndex = index;
        if (leftIndexNode < size && arr[leftIndexNode] > arr[maxIndex]) {
            maxIndex = leftIndexNode;
        }
        if (rightIndexNode < size && arr[rightIndexNode] > arr[maxIndex]) {
            maxIndex = rightIndexNode;
        }
        //调换位置
        if (maxIndex != index) {
            int t = arr[maxIndex];
            arr[maxIndex] = arr[index];
            arr[index] = t;
            //调换完之后，可能会影响到下面的子树，我们要再次调换
            toMaxheap(arr, size, maxIndex);
        }
    }
}

[0, 1, 2, 3, 4, 6, 7]

参考引用：必学十大经典排序算法，看这篇就够了(附完整代码动图优质文章)

tIndexNode < size && arr[rightIndexNode] > arr[maxIndex]) {
maxIndex = rightIndexNode;
}
//调换位置
if (maxIndex != index) {
int t = arr[maxIndex];
arr[maxIndex] = arr[index];
arr[index] = t;
//调换完之后，可能会影响到下面的子树，我们要再次调换
toMaxheap(arr, size, maxIndex);
}
}
}

```text
[0, 1, 2, 3, 4, 6, 7]

参考引用：必学十大经典排序算法，看这篇就够了(附完整代码动图优质文章)

@WAT
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构--排序（下）
weixin_43935646的博客
04-11 228
目录1、归并排序1.1代码实现1.2总结2、非比较排序2.1代码实现2.2总结3、排序算法复杂度及稳定性分析3.1时间复杂度3.2稳定性 1、归并排序   　归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两...
《数据结构与算法》-李春葆 实验报告-典型排序算法实践-快速排序
最新发布
12-20
数据结构与算法 - 快速排序算法实现报告 在数据结构与算法的学习过程中，快速排序算法是一种重要的排序算法，它具有排序速度快、就地排序的优点，但也具有不稳定性。以下是快速排序算法的详细实现报告。 快速排序...
排序算法之总结
专注于算法
12-05 1220
【版权声明：转载请保留出处：blog.csdn.net/algorithm_only。邮箱：liuy0711@foxmail.com】 前面几节讲了几种排序算法（包括算法思想、算法实现、算法分析），本节将要对这几种算法进行一个综合比较分析，大致有如下结果： 排序算法 平均时间 最坏情况 稳定性 辅助存储 直接插入排序
排序算法之初级排序
weixin_30616969的博客
12-06 136
该系列是我看人民邮电出版社的《算法》这本书的一些理解，不写下来感觉很快就忘掉，代码来自原书。 初级排序主要包括简单的选择排序和插入排序，以及插入排序的一个优化：希尔排序。 这里所说的排序，都是基于在原数组上的操作，比较和交换，不是新建一个数组来保存排序的结果。 一：选择排序 总的思想非常简单，就是在当前序列中，找到最小的元素，然后与首位元素交换位置。然后将无序的序列逐渐缩...
十分钟了解算法（0）——初始算法
小浩的博客
03-28 868
一：算法的定义 算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且毎条指令表示一个或多个操作。 二：算法的特性 输入（可以没有） 输出（至少一个） 有穷性 确定性 可行性 三：算法的要求 正确性：算法至少应该具有输入、输出和加工处理无歧义性、 能正确反映问题的需求、能够得到问题的正确答案。 可读性：便于阅读、理解和交流。 健壮性：当输入数据不合法时，算法也能做出相关处理，...
求解传输问题(二) 初始化算法
wangzhenyang2的博客
02-07 563
这篇文章介绍两种TP问题的初始化算法：Northwest-Corner和Minimum-Cell-Cost算法 还是用前一篇文章中的案例作为例子：三个Supply结点，其供应量为： 仓库 库存(Supply) 1. 堪萨斯 150 2. 奥马哈 175 3. 得梅因 275 Total 600 三个Demand结点，其需求量为： 面粉厂 需求(Demand) A. 芝加哥 200 B. 圣路易斯 100 C. 辛辛那提 300 Total 600
《数据结构与算法》-李春葆 实验报告-典型排序算法实践-基数排序
12-20
《数据结构与算法》实验报告-典型排序算法实践-基数排序 本实验报告的主要目的是通过基数排序算法的实现来掌握三类内部排序的设计思想、适用范围与算法实现，并深入理解和掌握优化排序算法的设计思想和实现过程。 ...
数据结构学习---排序
06-25
在实际应用中，选择排序算法时需要考虑数据规模、初始排列状态以及是否需要保持稳定性等因素。例如，对于小规模数据，简单的排序算法如冒泡排序可能足够；而对于大规模数据，快速排序、归并排序或堆排序通常是更好的...
Python数据结构和算法之希尔排序
12-21
希尔排序（Shell Sort）是一种基于插入排序的快速排序算法，由Donald Shell于1959年提出。它的主要思想是通过设置一个间隔序列（也称为步长），将待排序的数组分为若干个子序列，然后对每个子序列进行插入排序。随着...
java数据结构排序算法之归并排序详解
08-30
Java数据结构排序算法之归并排序详解 Java数据结构排序算法之归并排序是基于合并的思想，将两个或两个以上有序表合并成一个新的有序表。这种方法被称作是2-路归并排序（基本操作是将待排序列中相邻的两个有序子...
算法初始4
weixin_47017567的博客
04-16 83
给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字）。 示例 1: 输入: [2,3,-2,4] 输出: 6 解释: 子数组 [2,3] 有最大乘积 6。 示例 2: 输入: [-2,0,-1] 输出: 0 解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。 参考别人的实现。 class Solution { public: int maxPro...
数据结构-初始篇
weixin_43387852的博客
05-26 198
数据结构 前言一、什么是数据结构？ 二、算法的特性 三、时间复杂度和空间复杂度 前言     最近由于面试需要，所以重新学习了一遍数据结构，在此记录一下在学习过程中，总结的一些内容，供大家参考学习。 一、什么是数据结构？     根据百度百科的描述，对数据结构做出如下定义，     数据结构(data structure)是带有结构特性的数据元素的集合，它研究的是数据的逻辑结构和数据的物
面试时写不出排序算法？看这篇就够了。
weixin_33811961的博客
04-17 191
本文主要详细讲述常见的八种排序算法的思想、实现以及复杂度。 :notebook: 本文已归档到：「blog」 :keyboard: 本文中的示例代码已归档到：「algorithm-tutorial」 冒泡排序 要点 冒泡排序是一种交换排序。 什么是交换排序呢？ 交换排序：两两比较待排序的关键字，并交换不满足次序要求的那对数，直到整个表都满足次序要求为止。 算法思想 它重复地走访过要排序的数...
排序算法——冒泡排序
weixin_37646658的博客
01-26 1236
冒泡排序（python）
数据结构：排序趟数 / 比较次数与序列的原始状态有关的排序方法有哪些？
热门推荐
寒泉
10-26 10万+
先说结论 比较次数 与序列初态 无关 的算法是：二路归并排序、简单选择排序、基数排序 比较次数 与序列初态 有关 的算法是：快速排序、直接插入排序、冒泡排序、堆排序、希尔排序 排序趟数 与序列初态 无关 的算法是：直接插入排序、折半插入排序、希尔排序、简单选择排序、归并排序、基数排序 排序趟数与序列初态 有关 的算法是：冒泡排序、快速排序 关于排序趟数 插入排序、选择排序 趟数都是固定的 n-1。对于插入排序来说或，即使序列有序，也要依次从第二个元素开始，向前找它的插入位置。 冒泡排序 趟数与数据有关，优
各种排序算法时间复杂度、稳定性、初始序列是否对元素比较次数有关
hr10707020217的专栏
08-30 3万+
怎么记忆稳定性： 总过四大类排序：插入、选择、交换、归并（基数排序暂且不算） 比较高级一点的（时间复杂度低一点得）shell排序，堆排序，快速排序（除了归并排序）都是不稳定的，在加上低一级的选择排序是不稳定的。 比较低级一点的（时间复杂度高一点的）插入排序，               冒泡排序，归并排序，基数排序都是稳定的。 （4种不稳定，4种稳定）。 怎么记忆初始序列是否对元素的比较
序列初始化，指定值开始
fakergoing的博客
01-16 1332
要求每次用到这个序列的时候都从1开始  postgresql 为例子  使用之前每次都给他初始化为1   sql语句    alter sequence user_seq restart with 1 user_seq  序列名称      1 为初始值...
与数组初始状态无关的内排序算法
WJsuperrunner
03-14 4249
与数组初始状态无关的内排序算法非常感些  清风吹斜阳的总结，原文地址：http://www.cnblogs.com/Xieyang-blog/p/8340578.html首先，与初始状态无关分为几种情况1、算法复杂度与初始状态无关；2、元素总比较次数与初始状态无关；3、元素总移动次数与初始状态无关。【其实还有一种就是总排序趟数与初始状态无关，由于分析简单，除了快速排序的排序次数（递归深度）与关键字...
十大经典排序算法的总结
Create value with coding
11-25 1万+
前言 排序算法的术语： 稳定 ：如果 a 原本在 b 前面，而 a=b，排序之后 a 仍然在 b 的前面 不稳定 ：如果 a 原本在 b 的前面，而 a=b，排序之后 a 可能会出现在 b 的后面 内排序 ：所有排序操作都在内存中完成 外排序 ：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行 时间复杂度 ： 一个算法执行所耗费的时间 空间复杂度 ：运行完一个程序所需内存的大小 一些名词： n: 数据规模 k: “桶”的个数 In-place: 占用常数内存，不占用额外内存
《数据结构》C语言版-堆排序算法详解
本文主要探讨了数据结构中的堆排序算法，并引用了《数据结构》（C语言版）一书中的相关内容。堆排序是一种基于比较的排序算法，通过构建和调整最大堆或最小堆来实现数据的排序。文章还提到了其他相关数据结构和算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@WAT

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值