详解常见排序

已于 2024-09-24 09:12:02 修改
阅读量2.9k 收藏 150
点赞数 168
分类专栏： 算法 文章标签： 排序 JAVA
于 2024-09-24 08:04:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmh_1234567/article/details/140907729
版权

目录

​编辑

插入排序

希尔排序（缩小增量排序）

选择排序

冒泡排序

堆排序

快速排序

hoare版

 挖坑法

前后指针法

非递归版

归并排序

递归版

非递归版

计数排序

声明：以下排序代码由Java实现！！！

插入排序

步骤：

1.我们可以认为数组的第一个元素已经被排好序，因此只需考虑对后面的元素进行插入排序；

2.取下一个位置的元素val，让它和它之前的元素进行比较，顺序为从右向左；

3.如果该元素大于val，则将该元素移动到该元素所处位置的下一个位置；

4.重复步骤3，知道找到已排好序的序列中小于等于val的元素；

5.将值val放到该位置的下一个位置，如果已排好序的所有元素的值都大于val，则将val存放到数组下标为0的位置；

6.重复2~5步骤。

动画演示：

代码如下：

public static void insertSort(int[] array){
    for(int i=1;i<array.length;i++){
        int tmp=array[i];
        int j=i-1;
        for(;j>=0;j--){
            if(array[j]>tmp)
                array[j+1]=array[j];
            else
                break;
        }
        array[j+1]=tmp;
    }
}
折半插入排序 

在该值为val的元素找合适的位置时，是在已排好序的序列中进行找的，因此该过程可以使用二分查找（折半查找）来进行优化。

代码如下：

public static void bsInsertSort(int[] array){
    for(int i=0;i<array.length;i++){
        int tmp=array[i];
        int left=0,right=i;
        while(left<right){
            int mid=(left+right)>>1;
            if(tmp>=array[mid])
                left=mid+1;
            else
                right=mid;
        }
        for(int j=i;j>left;j--)
            array[j]=array[j-1];
        array[left]=tmp;
    }
}

时间复杂度：最好情况下为O(N)，此时待排数组为升序，或者说非常接近升序；

                     最坏情况下为O(N^N)，此时待排数组为降序，或者说非常接近降序。

空间复杂度：O(1)

稳定性：稳定

希尔排序（缩小增量排序）

思想：

先选定一个小于N的整数gap作为第一增量，然后将所有距离为gap的元素划分在同一组，对每组的元素进行直接插入排序，然后再选取一个比第一增量小的整数作为第二增量gap，然后将所有距离为gap的元素划分在同一组，对每组的元素进行直接插入排序，以此类推.........，直到增量减小为1时，此时就相当于整个数组被划分为一组，进行一次直接插入排序即可。

增量gap大于1时，称为“预排序”，使得待排数组接近有序；增量gap为1时，称为直接插入排序。

动画演示

代码如下：

public static void shellSort(int[] array){
    int gap=array.length;
    while(gap>1){
        gap=gap/3+1;
        shell(array,gap);
    }
}

private static void shell(int[] array,int gap){
    for(int i=gap;i<array.length;i++){
        int tmp=array[i];
        int j=i-gap;
        for(;j>=0;j-=gap){
            if(array[j]>tmp)
                array[j+gap]=array[j];
            else
                break;
        }
        array[j+gap]=tmp;
    }
}

平均时间复杂度：O(N^1.3)

空间复杂度：O(1)

选择排序

每一次从待排序列中选出最小（或者最大）的一个元素，存放在待排序列的起始位置，同时将待排序列原来起始位置的值放到待排序列中最小元素的位置，直到待排数据全部排完序。

动画演示

代码如下：

public static void selectSort(int[] array){
    for(int i=0;i<array.length;i++){
        int minIndex=i;
        for(int j=i+1;j<array.length;j++)
            if(array[j]<array[minIndex])
                minIndex=j;
        swap(array,i,minIndex);
    }
}

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

实际上，我们可以每一趟同时选择出待排序列中的最小值和最大值，然后将最小值放待排序列起始位置，将最大值放到待排序列的末尾，直到待排数据全部排完序，这样的话比前一种方法快一倍。

代码如下：

public static void DoubleSelectSort(int[] array){
    int left=0,right=array.length-1;
    while(left<right){
        int minIndex=left,maxIndex=left;
        for(int i=left+1;i<=right;i++){
            if(array[i]>array[maxIndex])
                maxIndex=i;
            if(array[i]<array[minIndex])
                minIndex=i;
        }
        swap(array,left,minIndex);
        if(maxIndex==left)
            maxIndex=minIndex;
        swap(array,right,maxIndex);
        left++;
        right--;
    }
}

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

时间复杂度：O(N^2)

空间复杂度：O(1)

冒泡排序

进行N趟，每一趟中，如果前一个位置的元素大于后一个位置的元素，则交换两个位置的元素。

动画演示

代码如下：

public static void bubbleSort(int[] array){
    for(int i=0;i<array.length;i++){
        boolean flag=false;
        for(int j=0;j<array.length-1-i;j++){
            if(array[j]>array[j+1]) {
                swap(array, j, j + 1);
                flag=true;
            }
        }
        if(!flag)
            break;
    }
}

时间复杂度：O(N^2)

空间复杂度：O(1)

堆排序

排升序建大根堆，排降序建小根堆。

以排升序为例，先对数组建立大根堆，然后将堆顶元素和堆最后一个元素交换，然后从堆顶进行向下调整，不过此时堆的大小要 -1，因为已经把最大的元素找出来并放在数组的末尾了，不断重复上述操作，直到将整个数组的元素排完序。

动画演示：

代码如下：

public static void heapSort(int[] array){
    createBigHeap(array);
    int end=array.length-1;
    while(end>0){
        swap(array,0,end);
        shiftDown(array,0,end);
        end--;
    }
}

private static void createBigHeap(int[] array){
    for(int parent=array.length-1-1;parent>=0;parent--)
        shiftDown(array,parent,array.length);
}

private static void shiftDown(int[] array,int parent,int end){
    int child=2*parent+1;
    while(child<end){
        if(child+1<end && array[child+1]>array[child])
            child++;
        if(array[parent]<array[child]){
            swap(array,parent,child);
            parent=child;
            child=2*parent+1;
        }
        else
            break;
    }
}

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

时间复杂度：O(N*logN)

空间复杂度：O(1)

快速排序
hoare版

步骤：

1.选定一个值Key，下标记为Keyi，通常是最左边的元素或者最右边的元素；

2.定义两个指针begin和end，being从左往右走，end从右往左走;

3.若选定的Key值是最左边的元素，需要end先走，若选定的Key值是最右边的元素，需要begin先走;

4.在走的过程中，当end遇到小于Key的数，才停下；然后begin开始走，直到遇到大于Key的数，然后交换位于begin和end位置的值，然后end再走，规则如上，直到begin和end相遇，此时再将位于Keyi位置的Key值和begin和end相遇点的值进行交换；

5.此时，Key左边的值都是小于等于Key的数，Key右边的值都是大于等于Key的数；

6.然后再对Key左边的数以及Key右边的数分别进行如上操作，直到待排序列只有一个元素为止。

动画演示：

代码如下： 

因为该方法包含大量的递归，当数据量较大时会发生栈溢出，因此做一些优化，包括【三数取中】和【当待排区间长度小于某个常数时，不再递归进行快排，而是使用直接插入排序】

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<=7){
        insertSortRange(array,start,end);
        return;
    }
    int pivot=partitionHoare(array,start,end);
    quick(array,start,pivot-1);
    quick(array,pivot+1,end);
}

private static void insertSortRange(int[] array,int begin,int end) {
    for (int i = begin+1; i <= end; i++) {
        int tmp = array[i];
        int j = i-1;
        for (; j >= begin ; j--) {
            if(array[j] > tmp) {
                array[j+1] = array[j];
            }else {
                break;
            }
        }
        array[j+1] = tmp;
    }
}

private static int midOfThree(int[] array, int left, int right) {
    int mid = (left+right) / 2;
    if(array[left] < array[right]) {
        if(array[mid] < array[left]) {
            return left;
        }else if(array[mid] > array[right]) {
            return right;
        }else {
            return mid;
        }
    }else {
        if(array[mid] > array[left]) {
            return left;
        }else if(array[mid] < array[right]) {
            return right;
        }else {
            return mid;
        }
    }
}

private static int partitionHoare(int[] array,int left,int right){
    int key=array[left];
    int keyi=left;
    while(left<right){
        while(left<right && array[right]>=key)
            right--;
        while(left<right && array[left]<=key)
            left++;
        swap(array,left,right);
    }
    swap(array,keyi,left);
    return left;
}

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

时间复杂度：O(N*logN)

空间复杂度：O(1) 

 挖坑法

步骤：

1.选定一个Key值，通常是位于最左边或者是最右边，在该位置形成一个坑；

2.定义两个指针left和right，left从左向右走，right从左向左走；

3.如果Key值位于数组最左边，需要right先走；如果Key值位于数组组右边，需要left先走；

4.在走的过程中，当end遇到小于Key的数，才停下，然后将right位置的值填放到坑位置，此时right位置处形成一个坑；然后begin开始走，直到遇到大于Key的数，然后将left位置的值填放到坑位置，此时left位置处形成一个坑；然后right再走，规则如上，直到left和right相遇，此时再将位于Key值填放到坑位置处；

5.此时，Key左边的值都是小于等于Key的数，Key右边的值都是大于等于Key的数；

6.然后再对Key左边的数以及Key右边的数分别进行如上操作，直到待排序列只有一个元素为止。

动画演示：

代码如下： 

因为该方法包含大量的递归，当数据量较大时会发生栈溢出，因此做一些优化，包括【三数取中】和【当待排区间长度小于某个常数时，不再递归进行快排，而是使用直接插入排序】

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<=7){
        insertSortRange(array,start,end);
        return;
    }
    int pivot=partitionHole(array,start,end);
    quick(array,start,pivot-1);
    quick(array,pivot+1,end);
}

private static void insertSortRange(int[] array,int begin,int end) {
    for (int i = begin+1; i <= end; i++) {
        int tmp = array[i];
        int j = i-1;
        for (; j >= begin ; j--) {
            if(array[j] > tmp) {
                array[j+1] = array[j];
            }else {
                break;
            }
        }
        array[j+1] = tmp;
    }
}

private static int midOfThree(int[] array, int left, int right) {
    int mid = (left+right) / 2;
    if(array[left] < array[right]) {
        if(array[mid] < array[left]) {
            return left;
        }else if(array[mid] > array[right]) {
            return right;
        }else {
            return mid;
        }
    }else {
        if(array[mid] > array[left]) {
            return left;
        }else if(array[mid] < array[right]) {
            return right;
        }else {
            return mid;
        }
    }
}


private static int partitionHole(int[] array,int left,int right){
    int key=array[left];
    while(left<right){
        while(left<right && array[right]>=key)
            right--;
        array[left]=array[right];
        while(left<right && array[left]<=key)
            left++;
        array[right]=array[left];
    }
    array[left]=key;
    return left;
}

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

时间复杂度：O(N*logN)

空间复杂度：O(1) 

前后指针法

步骤：

1.选定数组最左边的值为基准值；

2.定义两个指针prev和cur，开始时prev在最左边，cur在prev的下一个位置；

3.让cur向右走，如果cur位置的值大于基准值，只需cur继续向右移动，直到遇到比基准值小的值；

4.如果cur位置的值小于基准值，先让prev向右移动一个位置，然后交换prev位置的值和cur位置的值，直到cur走到数组末尾。

代码如下：

因为该方法包含大量的递归，当数据量较大时会发生栈溢出，因此做一些优化，包括【三数取中】和【当待排区间长度小于某个常数时，不再递归进行快排，而是使用直接插入排序】

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<=7){
        insertSortRange(array,start,end);
        return;
    }
    int pivot=partitionDouble(array,start,end);
    quick(array,start,pivot-1);
    quick(array,pivot+1,end);
}

private static void insertSortRange(int[] array,int begin,int end) {
    for (int i = begin+1; i <= end; i++) {
        int tmp = array[i];
        int j = i-1;
        for (; j >= begin ; j--) {
            if(array[j] > tmp) {
                array[j+1] = array[j];
            }else {
                break;
            }
        }
        array[j+1] = tmp;
    }
}

private static int midOfThree(int[] array, int left, int right) {
    int mid = (left+right) / 2;
    if(array[left] < array[right]) {
        if(array[mid] < array[left]) {
            return left;
        }else if(array[mid] > array[right]) {
            return right;
        }else {
            return mid;
        }
    }else {
        if(array[mid] > array[left]) {
            return left;
        }else if(array[mid] < array[right]) {
            return right;
        }else {
            return mid;
        }
    }
}


private static int partitionDouble(int[] array,int left,int right){
    int prev=left,cur=prev+1;
    while(cur<array.length){
        if(array[cur]<array[left] && array[++prev]!=array[cur])
            swap(array,prev,cur);
        cur++;
    }
    swap(array,prev,left);
    return prev;
}

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

时间复杂度：O(N*logN)

空间复杂度：O(1) 

非递归版

代码如下：

public static void quickSortNor(int[] array) {
    Stack<Integer> stack = new Stack<>();
    int left = 0;
    int right = array.length-1;
    int piovt = partitionHole(array,left,right);
    if(piovt - 1 > left) {
        stack.push(left);
        stack.push(piovt-1);
    }
    if(piovt + 1 < right) {
        stack.push(piovt+1);
        stack.push(right);
    }
    while (!stack.isEmpty()) {
        right = stack.pop();
        left = stack.pop();
        piovt = partitionHole(array,left,right);
        if(piovt - 1 > left) {
            stack.push(left);
            stack.push(piovt-1);
        }
        if(piovt + 1 < right) {
            stack.push(piovt+1);
            stack.push(right);
        }
    }
}
归并排序
递归版

使用递归不断将区间二分，直到区间只有一个元素为止，然后将两个区间进行排序合并，直到将所有区间合并完。

代码如下：

public static void mergeSort(int[] array){
    int[] dst=new int[array.length];
    dst= Arrays.copyOf(array,array.length);
    merge(array,dst,0,array.length-1);
    for(int i=0;i<array.length;i++)
        array[i]=dst[i];
}

private static void merge(int[] src,int[] dst,int start,int end){
    if(start>=end) return;
    int mid=(start+end)>>1;
    merge(dst,src,start,mid);
    merge(dst,src,mid+1,end);

    int i=start,j=mid+1,k=start;
    while(i<=mid || j<=end){
        if(j>end || (i<=mid && src[i]<src[j]))
            dst[k++]=src[i++];
        else
            dst[k++]=src[j++];
    }
}

时间复杂度：O(N*logN)

空间复杂度：O(N) 

非递归版

将整个区间划分为长度为1,2,4,8，..........最大为N的小区间，然后对相邻的长度为1,2,4,8，..........最大为N的小区间分别进行排序合并，最终就排好序了。

代码如下：

public static void mergeSortNor(int[] array){
    int[] src=array;
    int[] dst=new int[array.length];
    for(int step=1;step<array.length;step+=step){
        for(int start=0;start<array.length;start+=step*2){
            int mid=Math.min(start+step-1,array.length-1);
            int end=Math.min(start+2*step-1,array.length-1);
            int i=start,j=mid+1,k=start;
            while(i<=mid || j<=end){
                if(j>end || (i<=mid && src[i]<src[j]))
                    dst[k++]=src[i++];
                else
                    dst[k++]=src[j++];
            }
        }
        int[] tmp=src;
        src=dst;
        dst=tmp;
    }
    for(int i=0;i<array.length;i++)
        array[i]=src[i];
}

时间复杂度：O(N*logN)

空间复杂度：O(N) 

计数排序

先求出序列中的最大值maxVal和最小值minVal，然后开辟一个长度为maxVal-minVal+1的数组，值全都初始化为0，然后遍历整个数组，将下标为每个位置的值减去minVal处的值++，然后再重复将每个位置的值表示的次数次，将对应的值【下标+minVal】存放到原数组中。

动画演示：

代码如下： 

public static void countSort(int[] array) {
    int minVal = array[0];
    int maxVal = array[0];
    for (int i = 1; i < array.length; i++) {
        if(array[i] < minVal) {
            minVal = array[i];
        }
        if(array[i] > maxVal) {
            maxVal = array[i];
        }
    }
    int[] count = new int[maxVal-minVal+1];
    
    for (int i = 0; i < array.length; i++) {
        count[array[i]-minVal]++;
    }
    
    int index = 0;
    for (int i = 0; i < count.length; i++) {
        while (count[i] > 0) {
            array[index] = i+minVal;
            index++;
            count[i]--;
        }
    }
}

时间复杂度：O(N)

空间复杂度：O(N) 

新绿MEHO
关注
专栏目录
java实现数据结构常见排序算法及详解
11-08
### Java 实现数据结构常见排序算法及详解 #### 排序算法概述 排序算法是计算机科学中的基础概念之一，主要用于将一系列数据按照特定规则进行排列。根据数据处理方式的不同，排序算法大致分为两大类：比较排序与非...
JavaScript中常见排序算法详解共19页.pdf.z
11-21
本资料“JavaScript中常见排序算法详解共19页.pdf.zip”提供了一份详尽的教程，涵盖了JavaScript中常用的各种排序算法。下面我们将深入探讨这些排序算法。 1. 冒泡排序（Bubble Sort）：这是一种简单的排序算法，...
常见排序算法详解
a-clear-meaning的博客
11-05 2171
常见排序算法详解，包含希尔排序，堆排序，快速排序，归并排序，计数排序等排序算法的动态图展示，静态图剖析，方法总结和代码实现示例，属实是优质分享，不容错过呦！
所有常见排序详解
2021wuwei
02-26 1833
2.3希尔排序（缩小增量排序） 3.选择排序 3.1基本思想 4.交换排序 4.1基本思想 4.3快速排序 4.3.2递归+三数取中+小区间优化 4.3.3非递归+三数取中 5.归并排序 5.1基本思想 5.3归并非递归 5.3.1为什么不能使用栈......
快速排序详解
LiangXiay的博客
11-19 11万+
1.什么是快速排序 我们知道排序有很多种，常见的如希尔排序，插入排序，选择排序，堆排序等等，而快速排序也是排序家族中的一员。因为其在大多数情况下有着优秀的综合性能，快速排序的快速也算是实至名归，接下来就为大家讲解快速排序的思想与实现。 2.快速排序的核心思想 快速排序通过多次比较与交换来完成排序。而这个过程又被分为了多次重复单趟排序，接下来我们先从每一趟的排序讲起。 快速排序的单趟排序思想是： 在一个无序数组中取一个数key，每一趟排序的最终目的是：让key的左边的所有数小于key，key的右边都
常见八大排序详解
qq_56999918的博客
11-20 3万+
冒泡排序： 冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。 作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交
常见的排序算法汇总（详解篇）
m0_73634434的博客
08-19 1927
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。稳定性 ：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中， r[i]=r[j] ，且 r[i] 在 r[j] 之前，而在排序后的序列中， r[i] 仍在 r[j] 之前，则称这种排序算法是稳定的；否则称为不稳定的。数据元素全部放在内存中的排序。数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
热门推荐
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
十大经典排序算法详解
yunweigo的博客
05-26 2219
本文转自 《卢明冬的博客》 相关的同学可以关注一下 文章目录排序算法的分析和评价2.十大排序经典算法总览2.1 排序算法的分类 排序算法是《数据结构和算法》中非常基础的算法，但却占据着十分重要的位置，几乎可以说是我们在日常编程代码中使用最频繁的基础算法。本文对常见的十大经典排序算法进行了详细的知识点梳理，从排序思路、动图演示、代码实现、复杂度分析、算法优化等多个方面分别对不同的排序算法进行讲解，内容详实，一篇文章几乎囊括了排序算法所有必知必会的知识点，夸张点说，算得上是 “史上最全” 排序算法讲解。
十大排序算法详解
陈陈陈亚萌_的博客
08-02 1792
十大排序算法详解 参考程序员必知必会的十大排序算法详解 引言 对于排序的分类，可以将排序算法分为两大类：基于比较和非比较的算法。 基于比较的排序算法可以细分为： 基于交换类：冒泡排序、快速排序 基于插入类：直接插入排序、希尔排序 基于选择类：简单选择排序、堆排序 基于归并类：归并排序 基于非比较的排序算法可以分为：桶排序、计数排序和基数排序。也有人将排序归纳为8大排序，原因是基数排序...
常见排序算法之基数排序详解
qq_43507104的博客
03-17 965
基数排序是一种非比较排序，它属于分配式排序（distribution sort）。基数排序是一种高效的排序算法，它可以突破比较类排序算法的极限（nlogn），其时间复杂度可以表示为O(Kn)。其中n就是待排序序列的元素个数，K是数字的位数。 1. 算法思想 算法思想是这样的，说白就是先排序个位，在排序十位…如图中数组， 1.首先确定排序次数：最大值几位数就要排序几次，图中数组最大值为345需要排...
JavaScript中常见排序算法详解共19页.pdf.zip
10-28
本资料"JavaScript中常见排序算法详解共19页.pdf.zip"涵盖了JavaScript中的一些主要排序算法，旨在帮助开发者深入理解和熟练运用这些算法。 首先，我们来了解一下排序算法的基本概念。排序是将一组数据按照特定顺序...
Java 7大常见排序方法实例详解
08-30
本篇文章将深入解析Java中常见的七种排序方法，包括直接插入排序、希尔排序、冒泡排序、选择排序、快速排序、归并排序以及堆排序。 1. 直接插入排序（直接插入排序） 直接插入排序是一种简单的排序方法，它将未排序...
python的练习题2
10-16
python的练习题2
行人重识别-用于行人重识别的稀疏标签平滑正则化优化-附项目源码+流程教程-优质项目实战.zip
10-16
行人重识别_用于行人重识别的稀疏标签平滑正则化优化_附项目源码+流程教程_优质项目实战
php语言基础（精编版65页ppt）.pdf
10-16
php语言基础（精编版65页ppt）.pdf
9217968970910743X8.5CM模板 横.psd
最新发布
10-16
9217968970910743X8.5CM模板 横.psd
Datawhale精彩SQL项目复制和学习笔记.zip
10-16
Datawhale精彩SQL项目复制和学习笔记
毕业设计论文SpringBoot+Vue川剧科普平台.docx
10-16
毕业设计论文
评论 231
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

新绿MEHO

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

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

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

打赏作者

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

抵扣说明：

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

余额充值