十大排序算法-JAVA

最新推荐文章于 2022-05-25 16:59:28 发布
最新推荐文章于 2022-05-25 16:59:28 发布
阅读量288 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45498245/article/details/115433689
版权

文章目录


在这里插入图片描述

1、冒泡排序

/**
 * @Description:
 * @ClassName algorithm
 * @Author: 王瑞文
 * @Date: 2021/3/24 19:31
 */
public class Test {

    public static void main(String[] args) {
        int arr[] = {1, 2, 3, 4, 5, 12, 32};
        bubbleSort(arr);
        for (int i : arr) {
            System.out.print(i+"  ");
        }

    }

    //冒泡排序
    public static void bubbleSort(int[] arr) {

        for (int end = arr.length; end > 0; end--) {
            boolean isSort = true;//优化的 === 前提是如果已经排好序的
            for (int begin = 1; begin < end; begin++) {
                if (arr[begin - 1] > arr[begin]) {
                    isSort = false;
                    int tem = arr[begin];
                    arr[begin] = arr[begin - 1];
                    arr[begin - 1] = tem;
                }
            }
            if (isSort)
                break;
        }
    }

}

优化

  • 如果序列已经完全有序，可以提前终止冒泡排序在这里插入图片描述
    **第一种优化:**在第一个For循环中定义一个boolean值为true，在第一轮中 如果发生交换就把布尔值设置为false。等里边那层循环完了就知道是不是有序的了。上边有代码

  • 如果序列尾部已经局部排序，可以记录最后一次交换的位置，减少比较次数在这里插入图片描述

    第二种优化： 记录最后一次的交换位置，减少比较次数

//冒泡排序
public static void bubbleSort(int[] arr) {
    for (int end = arr.length; end > 0; end--) {
        int sortIndex = 0;
        for (int begin = 1; begin < end; begin++) {
            if (arr[begin - 1] > arr[begin]) {
                int tem = arr[begin];
                arr[begin] = arr[begin - 1];
                arr[begin - 1] = tem;
                sortIndex = begin;
            }
        }
        end = sortIndex;

    }
}

复杂度

时间复杂度：

  • 最坏（完全乱序）==（1+2+3+4+…+n-1）
    • O(n²)
  • 最好时间复杂度 扫描一次就发现了是拍好顺序的
    • O(n)

空间复杂度：

  • 没有用到别的堆或者递归调用
    • O(1)

稳定性：

  • 如果相等的2个元素，在排序前后的相对位置保持不变，那么这是稳定的排序算法

冒泡排序是稳定的且是原地算法

2、选择排序

从序列中找出最大的元素，然后与最末尾的元素交换位置

执行完一轮，最后一个位置的就是最大元素

排除最后一个位置继续找

package easy.排序.选择排序.简单的选择排序;

/**
 * @Description:
 * @ClassName algorithm
 * @Author: 王瑞文
 * @Date: 2021/3/24 22:19
 */
public class Test {
    public static void main(String[] args) {
        int arr[] = {1, 2, 3, 4, 12, 32,8,20,10};
        for (int end = arr.length - 1; end > 0; end--) {
            int maxIndex = 0;
            for (int begin = 1; begin <= end; begin++) {
                if (arr[maxIndex] < arr[begin]) {//compare 比较
                    maxIndex = begin;
                }
            }
            // 交换位置
            int temp = arr[maxIndex];
            arr[maxIndex] = arr[end];
            arr[end] = temp;
        }
        for (int i : arr) {
            System.out.print(i+"  ");
        }
    }


}

优化

可以使用堆来进行找最大值

堆的时间复杂度是O(log(n))

这样优化下来外边加一层循环时间复杂度就是O(nlog(n))

复杂度

时间复杂度：

  • O(n²)
  • 最好、最坏、都是O(n²)

空间复杂度：

  • O(1)

属于稳定排序

选择排序交换次数要远远少于冒泡排序，平均性能优于冒泡排序

3、堆排序

堆排序可以认为是对选择排序的优化

在挑最大值的时候时间复杂度是O(log(n))

流程：

  • 对数据进行原地建堆（heapify）
  • 重复一下操作，直到堆的元素数量为1
    • 交换堆顶元素与尾元素
    • 堆元素数量减一
    • 对0位置进行过一次siftDown操作

Top K 问题

  • 什么是Top K问题
  • 从海量数据中找出前K个数据

比如：从100万个整数中找出最大的100个整数

  • Top K 问题的解法之一：可以用数据结构"堆来解决"

二叉堆

  • 如果任意节点的值总是≥子节点的值，称为：最大堆、大根堆、大顶堆
  • 如果任意节点的值总是≤子节点的值，称为：最小堆、小根堆、小顶堆

一般使用数组实现二叉堆

用数组实现它索引的规律：（n为元素数量，i为数组索引）

  • 如果i=0,它是根节点
  • 如果i>0，它父节点的编号为floor((i-1)/2)
  • 如果2i+1≤n-1，它的左子节点编号为2i+1
  • 如果2i+1>n-1，它无左子节点
  • 如果2i+2≤n-1，它的右子节点编号为2i+2
  • 如果2i+2>n-1，它无右子节点

那么如何建立一个二叉堆呢？

以数组的形式 主要就是在添加的时候就进行上滤操作去排号数组顺序那么接下来着重说一下添加八

添加

@Override
public void add(E element) {

    elementNullCheck(element);//检查添加元素是否为空

    ensureCapacity(size + 1); //数组是否需要扩容

    elements[size++] = element;// 还需要检测是否满足最大/最小堆的特性

    siftUp(size - 1);//最后于一个元素上滤 ** 主要是这个方法

}

//上滤
private void siftUp(int node) {
    E element = elements[node];
    while (node > 0) {
        int parentIndex = (node - 1) >> 1;
        E parent = elements[parentIndex];
        //小于父节点位置合适，直接退出
        if (compare(parent, element) >= 0) break;
        //调换位置
        elements[node] = parent;
        node = parentIndex;
    }
    elements[node] = element;
}

删除

在这里插入图片描述

批量建堆

  • 自上而下的上虑（除了根节点都下虑） O(nlog(n))
    在这里插入图片描述

  • 自下而上的下虑 （一半节点下虑） --效率高 O(n)

在这里插入图片描述

4、插入排序

package easy.排序.插入排序.简单插入排序;

/**
 * @Description:
 * @ClassName algorithm
 * @Author: 王瑞文
 * @Date: 2021/3/5 23:06
 */
public class Test {
    static void insert(int[] nums) {
        System.out.println("排序前：");
        for (int num : nums) {
            System.out.print(num + "  ");
        }
        System.out.println("");
        for (int begin = 1; begin < nums.length; begin++) {
            int n = begin;
            while (n > 0 && nums[n] < nums[n - 1]) {

                int temp = nums[n];
                nums[n] = nums[n - 1];
                nums[n - 1] = temp;
                n--;
            }

        }

        System.out.println("排序后：");
        for (int num : nums) {
            System.out.print(num + "  ");
        }
    }

    public static void main(String[] args) {

        insert(new int[]{2, 5, 6, 8, 1, 786, 54, 7, 27, 3, 556, 37});

    }
}

时间复杂度

逆序对：

数组<2,3,8,6,1>的逆序对为：<2,1> 、< 3,1> <8,6> <8,1> <6,1>

插入排序的时间复杂度与逆序对的数量成正比

逆序对的数量越多，时间复杂度越高

如果一个逆序对达到最大说明数组时降序的，插入排序时间复杂度非常高!O(n²)

最坏情况，完全降序下就是O(n²)

最好情况，完全升序下就是O(n)

空间复杂度

O(1)

5、归并排序

执行流程

  • 不断的将当前序列平均分割成两个子序列直到不能分割
  • 不断地将2个子序列合并成一个有序序列

在这里插入图片描述

在这里插入图片描述

时间复杂度

归并排序花费时间：

T(n)=T(n/2)+T(n/2)+O(n)=O(X) 求X ==>T(n)=2*T(n/2)+O(n)

两边都除n

T(n)/n=T(n/2)(n/2)+O(1)

一系列操作之后可以算出来复杂度为O(nlogn)

package easy.排序.归并排序;

import utils.RandomArrays;

/**
 * @Description:
 * @ClassName algorithm
 * @Author: 王瑞文
 * @Date: 2021/3/27 20:37
 */
public class Test {
    private static Integer array[] = RandomArrays.getRandomArray(10, 10, 200);
    private static Integer leftArray[];

    public static void sort() {
        leftArray = new Integer[array.length >> 1];
        sort(0, array.length);
    }

    /**
     * 对begin到end的范围内的数据进行排序 [begin,end)
     *
     * @param begin
     * @param end
     */
    public static void sort(int begin, int end) {
        if (end - begin < 2) return;
        int mid = (begin + end) >> 1;
        sort(begin, mid); //耗时 Tn(/2)
        sort(mid, end);//耗时 Tn(/2)
        merge(begin, mid, end);
    }

    /**
     * 将[begin,mid)和[mid,end)范围的序列合并成一个有序序列
     *
     * @param begin
     * @param mid
     * @param end
     */
    public static void merge(int begin, int mid, int end) {
        int li = 0, le = mid - begin;//li是左边数组的begin le是左边数组的end
        int ri = mid, re = end;//ri是右边数组的begin，re是右边数组的end
        int ai = begin;//标识覆盖的位置

        /**
         * 备份左边数组
         */
        for (int i = li; i < le; i++) {
            leftArray[i] = array[begin + i];//这个并不一定是 0开始的
        }

        while (li < le) {//如果左边没有结束
            if (ri < re && array[ri] < leftArray[li]) {//左边大
                array[ai++] = array[ri++];
            } else {
                array[ai++] = leftArray[li++];//右边大
            }
        }


    }

    public static void main(String[] args) {
        sort();
        System.out.println("排序后：");
        for (Integer integer : array) {
            System.out.print(+integer + " ");
        }
    }


}

6、快速排序

  • 主要是从序列中找轴点元素（pivot）
  • 利用pivot将序列分割成两个子序列
  • 对子序列继续进行上述操作直到子序列剩下一个元素
    在这里插入图片描述

时间复杂度

  • 每次轴点都是中间位置的情况下是最好的情况 T(n)=T(n/2)+T(n/2)+O(n)
    • O(nlogn)
  • 如果轴点左右元素极度不均匀 T(n)=T(n-1)+O(n)
    • O(n²)

在这里插入图片描述

  • 为了降低最坏情况的出现概率，一般采取的做法是随机选择轴点元素，然后把选择的轴点元素和begin的位置交换一下就可以了

空间复杂度

  • O(logn)

不稳定排序

package easy.排序.交换排序.快速排序;

import utils.RandomArrays;

/**
 * @Description:
 * @ClassName algorithm
 * @Author: 王瑞文
 * @Date: 2021/3/24 19:31
 */
public class Test {
    private static Integer array[] = RandomArrays.getRandomArray(10, 100, 200);


    /**
     * 对[begin,end)范围内的元素进行快速排序-->轴点构造的一个过程
     *
     * @param begin
     * @param end
     */
    private static void sort(int begin, int end) {
        if (end - begin < 2) return;

        //确定轴点位置
        int pivotIndex = pivotIndex(begin, end);
        //对左右子序列也快速排序 O(n)
        sort(begin, pivotIndex);
        sort(pivotIndex + 1, end);


    }

    /**
     * 确定[begin) 范围的轴点位置 -->找出轴点应该在哪。
     *
     * @param begin
     * @param end
     * @return 轴点元素的下标
     */
    private static int pivotIndex(int begin, int end) {
        //备份begin位置的元素
        int pivot = array[begin];

        end--; //将end指向最后一个元素

        //左右交换扫面 从右边开始
        while (begin < end) {
            while (begin < end) {
                if (array[end] - pivot> 0) {//end元素比轴点元素大
                    end--;
                } else { //end元素比轴点元素小
                    array[begin++] = array[end];
                    break;
                }
            }
            while (begin < end) {
                if (array[begin] - pivot < 0) {//begin元素比轴点元素小
                    begin++;
                } else {//begin元素比轴点元素大
                    array[end--] = array[begin];
                    break;
                }
            }
        }
        //放入轴点元素
        array[begin] = pivot;
        //执行完之后肯定begin=end 所以返回begin或者end都可以
        return begin;
    }

    public static void main(String[] args) {
        sort(0, array.length);
        System.out.println("排序后：");
        for (Integer integer : array) {
            System.out.print(integer + "  ");
        }
    }
}

7、希尔排序

按列进行排序
在这里插入图片描述

时间复杂度

最坏情况下是O(n²)

最好是O(n)

空间复杂度

O（1） 原地排序

不稳定

package easy.排序.插入排序.希尔排序;

import utils.RandomArrays;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description:
 * @ClassName algorithm
 * @Author: 王瑞文
 * @Date: 2021/3/6 21:46
 */
public class Test {


    private static Integer[] array = RandomArrays.getRandomArray(10, 100, 200);
    private static List<Integer> step = sellStep(array.length);

    public static void sort() {
        for (Integer integer : step) {
            sort(integer);
        }

    }

    /**
     * 默认用希尔德步长序列
     *
     * @return
     */
    private static List<Integer> sellStep(int step) {
        List<Integer> steps = new ArrayList<>();
        //16-> 8 ,4,2,1

        while ((step >>= 1) > 0) {
            steps.add(step);
        }
        return steps;
    }

    /**
     * 分成step列进行排序
     *
     * @param step
     */
    public static void sort(int step) {

        for (int col = 0; col < step; col++) {//col是列数 对第cole列进行排序

            //插入排序
            // col、clo+step、col+2*step、col+3*step 第一个不需要排序所以从clp+step开始
            for (int begin = col + step; begin < array.length; begin += step) {
                int n = begin;
                while (n > col && array[begin] < array[begin - step]) {
                    int temp = array[n];
                    array[n] = array[n - step];
                    array[n - step] = temp;
                    n--;
                }
            }
        }

    }

    public static void main(String[] args) {
        sort();
        System.out.print("排序后：  ");
        for (Integer integer : array) {
            System.out.print(integer+" ");
        }
    }
}

一些非比较排序

1.计数排序（非比较）

统计每个整数再序列中出现的次数，进而推导出每个证书再有序序列中的索引在这里插入图片描述

  • 非比较排序是利用空间换时间，时间复杂度可以比O(nlogn)更低
时间复杂度

平均、最好、最坏都是O(n+k)

空间排序

O(n+k)

不稳定排序

2.基数排序（非比较）

  • 依次对个位数、十位数、百位数、千位数…进行排序在这里插入图片描述

个十百千位的取值范围都是固定的0~9，所以可以使用计数排序对他们进行排序

时间复杂度

O(d*(n+k)):d是最大值的位数，k是进制。属于稳定排序

空间复杂度

O（n+k）

10、桶排序（非比较）

  • 创建一定数量的桶（比如用数组、链表作为桶）
  • 按照一定规则，将序列中的元素均匀分配到对应的桶
  • 分别对桶进行单独排序
  • 将非空桶进行合并

了解

素净小凡人
关注
专栏目录
十大经典排序算法（java实现、配图解，附源码)
pythonxxoo的博客
03-03 2100
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 前言： 本文章主要是讲解我个人在学习Java开发环境的排序算法时做的一些准备，以及个人的心得体会，汇集成本篇文章，作为自己对排序算法理解的总结与笔记。 内容主要是关于十大经典排序算法的简介、原理、动静态图解和源码实现的分析。 对于一名程序员来讲，我们都知道数据结构与算法起初是用
Java实现几种常见排序算法代码
janch1的专栏
03-01 307
排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个关键字有序的序列 稳定度（稳定性） 一个排序算法是稳定的，就是当有两个相等记录的关键字R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。 排序算法分类 常见的有插入（插入排序/希尔排序）、交换（冒泡排序/快速排序）、选择（选择排序）
【堆】堆的数据结构，以及堆排序的优缺点、时间复杂度分析
GEEK-BANANA
08-10 8460
本来想写堆以及优先队列的，现在就只简单写写堆吧，先不写别的了，先把堆搞明白。 堆是什么 堆是一个 完全二叉树，每一个节点的值都必须 大于等于 或者 小于等于 其孩子节点的值。 堆的特点 插入 的时间复杂度：O(lgn) 删除 的时间复杂度：O(lgn) 获取最大值/最小值的 时间复杂度：O(1) 最大堆/最小堆 最大堆：每一个节点的值都必须 大于等于 其孩子节点的值。 最小堆：每一个节点的值都必须 小于等于 其孩子节点的值。 构建最大堆 构建最大堆的步骤分为一下几步： 把要插入的元素插入到堆中 和父节点
＜数据结构＞堆和堆排序
weixin_63246064的博客
05-25 356
目录 一、堆的概念及结构 二、堆的实现 2.1.堆向下调整算法 2.2.堆的创建 2.3.建堆时间复杂度 2.4.堆的插入 2.5.堆的删除 三、堆的应用 3.1. 堆排序 3.2. TOP-K问题 一、堆的概念及结构 如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足： = 且 >= ) i = 0，1， 2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆
算法-堆排序及时间复杂度分析
博学之,审问之,慎思之,明辨之,笃行之
05-08 5617
堆结构 1）堆结构就是用数组实现的完全二叉树结构。（完全二叉树：叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部。） 2）完全二叉树中如果每棵子树的最大值都在顶部就是大根堆 3）完全二叉树中如果每棵子树的最小值都在顶部就是小根堆 4）堆结构的heapInsert（插入）与heapify（调整）操作 5）堆结构的增大和减少 6）优先级队列结构，就是堆结构 语言提供的堆结构 vs 手写的堆结构 取决于我们有没有动态改信息的需求。 语言提供的堆结构，如果你动态改数据，不保证依然有序 [ 手写堆
Monkey King【大根堆】
既然弱小，就只顾变强就是了
10-04 263
题目链接 有N只孤独的猴子，然后他们会打M次架，每次打架的两只猴子战斗力减半，并且会成为朋友，朋友的朋友也是朋友，问的是朋友中战力最大的猴子是有多少战力？ 于是，考虑维护这样的一个大根堆，每次将小的大根堆推给大的，相当于是启发式合并的操作，复杂度。 或者，我们可以直接进行维护，我们维护一个二叉树的“深度”，然后尽量保证深度平衡，也就是使得整棵二叉树的深度尽可能小，所以，我们定义一个dist，表示它和它的子树中的dist最小的值+1，但是这样的维护最后可能退化会形成一条链，不妥，不如我们让左...
排序算法-SortingAlgorithm-java.zip
最新发布
09-26
堆排序 1.选择排序 Selection Sort 2.冒泡排序 Bubble Sort 3.插入排序 Insertion Sort 4.归并排序 Merge Sort 5.快速排序 Quick Sort 6.堆排序 Heap Sort 7.总结 summary
排序算法-基于Java实现的排序算法之BubbleSort实现.zip
03-27
本项目聚焦于一种基础且经典的排序算法——冒泡排序（Bubble Sort），并以Java编程语言作为实现工具。Java是一种广泛使用的面向对象的编程语言，其简洁的语法和丰富的库函数使得实现各种算法变得方便。 冒泡排序是...
详解Java常用排序算法-插入排序
08-26
Java排序算法 - 插入排序 插入排序（Insertion Sort）是一种简单的排序算法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增 1 的有序表。该算法的实现非常简单，但其时间复杂度...
详解Java常用排序算法-选择排序
08-26
详解Java常用排序算法-选择排序 选择排序（Selection Sort）是一种简单的排序算法，它的基本思想是每次从待排序的元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的元素排完。 选择...
堆的时间复杂度，空间复杂度
Xurui_Luo的博客
06-14 3011
时间复杂度 分成初始化堆和取出最大/小元素后修改堆两个过程看 建堆过程O(n) 取出最大/小元素后修改堆O(nlog⁡n)O(n \log n)O(nlogn) 总的来讲，堆的时间复杂度为O(nlog⁡n)O(n \log n)O(nlogn) 空间复杂度 直接对现有的数据结构进行排序，因此是O(1)O(1)O(1) 参考 排序算法之 堆排序 及其时间复杂度和空间复杂度 ...
堆排序自下而上建立大根堆时间复杂度为O(n)的证明
USTC暖暖的博客
12-20 2620
建立大根堆时，设有n个记录的初始序列所对应的完全二叉树的深度为h,建初堆时，每个非终端结点都要自上而下进行＂筛选＂。由于第i层上的结点数小于等于i-1,且第i层结点最大下移的深度为h-i,每下移一层要做两次比较，所以建初堆时关键字总的比较次数为: h=⌊log2(n)⌋+1 h=\lfloor log_2(n)\rfloor+1h=⌊log2​(n)⌋+1 2h≤n+12^h\leq n+1 2h≤n+1 ∑i=h−112i−1⋅2⋅(h−i)=∑i=h−112i(h−i) \sum_{i=h-1}^1 2
堆排序的时间复杂度分析
yizhiniu_xuyw的专栏
11-10 1万+
堆排序包括两个阶段，初始化建堆和重建堆。所以堆排序的时间复杂度由这两方面组成，下面分别进行分析。先post一个实现代码，便于分析。 #include <stdio.h> void swap(int *a, int *b); void adjustHeap(int param1,int j, int inNums[]); void HeapSort(int nums, int inNums[]); //大根堆进行调整 void adjustHeap(int param1, int j, i
排序算法之 堆排序 及其时间复杂度和空间复杂度
热门推荐
YuZhiHui_No1的专栏
03-14 5万+
堆排序是由1991年的计算机先驱奖获得者、斯坦福大学计算机科学系教授罗伯特.弗洛伊德(Robert W．Floyd）和威廉姆斯(J．Williams）在1964年共同发明了的一种排序算法（ Heap Sort )； 堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非
堆排序及复杂度分析
bury_pen
02-18 7377
文章目录什么是堆？如何构建一个堆？代码实现修改大顶堆根节点的值，如何再次将其形成大顶堆？代码实现如何实现堆排序？代码实现时间复杂度分析 &amp;nbsp; 什么是堆？ 可以理解为 堆就是一棵完全二叉树。 完全二叉树：假设一棵二叉树的深度是h，若其满足第1~(h-1)层的节点数达到最大个数，第h层的节点都连续出现在最左边，我们称其为完全二叉树。 &amp;nbsp; 堆又分为 大顶堆和小顶堆。 大顶堆：父节点的...
大小堆详解&C++实现&复杂度分析
silverBlack
07-13 5034
大小堆介绍部分转载自：二叉堆之图文解析 二叉堆的删除、复杂度分析和代码是自己写的~ 堆和二叉堆的介绍 堆的定义 堆(heap)，这里所说的堆是数据结构中的堆，而不是内存模型中的堆。堆通常是一个可以被看做一棵树，它满足下列性质：[性质一] 堆中任意节点的值总是不大于(不小于)其子节点的值；[性质二] 堆总是一棵完全树。将任意节点不大于其子节点的堆叫做最小堆或小根堆，而将任意节点不...
堆排序中建堆过程的时间复杂度O(n)的证明
anonymalias的专栏
04-16 2万+
下面是建立大根堆的代码 template void CreateBigRootHeap(Type *array, int len) { int i, j, k; Type temp; for (i = (len - 1) / 2; i >= 0; --i) { temp = array[i]; k = i;
堆的时间复杂度
weixin_30335575的博客
08-06 1847
构建堆的过程，O（N） 从下面的元素向下沉 package sortdemo; import java.util.Arrays; /** * Created by chengxiao on 2016/12/17. * 堆排序demo */ public class HeapSort { public static void main(String []a...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值