Lesson2：常用的排序算法

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

目录

一、概念

二、直接插入排序

2.1 原理

2.2 实现

2.3 性能分析

三、希尔排序

3.1 原理

3.2 实现

3.3 性能分析

四、选择排序

4.1 原理

4.2 实现

         4.3 性能分析

五、堆排序

5.1 原理

5.2 实现

         5.3 性能分析

六、冒泡排序

6.1 原理

6.2 实现

6.3 性能分析

七、快速排序

7.1 快速排序的递归实现

7.1.1 原理

7.1.2  挖坑法

7.1.3  hoare法

7.1.4 优化

7.2 非递归实现

7.3 性能分析

 7.4 总结

八、归并排序

8.1 原理

8.2 归并排序的递归实现

8.3 归并排序的非递归实现

8.4 性能分析

 九、排序总结

一、概念

时间复杂度：评估执行程序所需的时间。可以估算出程序对处理器的使用程度。

空间复杂度：评估执行程序所需的存储空间。可以估算出程序对计算机内存的使用程度。

稳定性：两个相等的数据，如果经过排序后，排序算法能够保证其相对位置不发生变化，则称该算法稳定。

一个稳定的算法，可以被实现为不稳定的排序。

但一个不稳定的算法，无法被实现为稳定的算法。

常见的排序算法：

二、直接插入排序

2.1 原理

插入：前提是[0,i-1]下标的数组都有序，将array[i]放在合适的位置，使得[0,i]之间的元素都有序。 

具体操作：遍历array[i-1]到array[0]之间的元素，用array[j]来表示，如果比array[j]比array[i]大，array[j]就往后挪动,即array[j+1] = array[j]。j--，当遇见array[j]<array[i]或者j<0(遍历结束都还没找到比array[i]小的)，就让array[j+1]= tmp。

2.2 实现

public static void insertSort(int[] array){
        if(array == null){
            return;
        }
        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;
        }
    }

2.3 性能分析

时间复杂度

空间复杂度
稳定性

稳定

插入排序，数据越接近有序，时间效率越高。一般插入排序会用到一些需要优化的地方。

三、希尔排序

3.1 原理

希尔排序是对直接插入排序的一个优化。在排序之前，先分组，组内进行直接插入排序。

分组采用的缩小增量法，最后的增量必须为1.

直接插入排序就是希尔排序gap=1的情况。

格局小了，快来康康大佬是如何分组的。

3.2 实现

public static void shellSort(int[] array){
        if(array == null){
            return;
        }
        int gap = array.length;
        while(gap > 1){
            gap = gap/2;
            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;
            }
        }
    }

3.3 性能分析

时间复杂度

空间复杂度
稳定性

不稳定

四、选择排序

4.1 原理

假设数组长度为elem，数组长度为len.

第一趟，假设第一个元素elem[0]是最小的，从elem[1]开始遍历数组，若是遇见的元素比elem[0]小，交换这两个元素。保证elem[0]存到元素是最小的。第一遍遍历结束后，最小的元素存在elem[0]当中。

第二趟，由于elem[0]已经存放最小的元素，不用再调整位置了，第二次假设elem[1]是elem[1]到elem[len-1]中最小的元素，从elem[2]开始遍历数组，若是遇见比elem[1]小的元素就交换位置，保证elelm[1]中存的是elem[1]-elem[len-1]中最小的元素。

即：第i (从i=0开始) 次遍历数组，假设elem[i]是最小的元素，从elem[i+1]开始遍历数组，遇见比elem[i]小的就交换位置。

基于上述思路，选择排序有两种思路：

第一种：假设elem[i]是最小的元素，从elem[i+1]开始遍历数组，遇见比elem[i]小的就交换位置。这种思路每次遇见比elem[i]小的都会交换。

第二种：假设min下标所指的元素最小，未比较之前假设min=i；从elem[i+1]开始遍历数组，遇见比elem[i]小的就跟新 i 的值，遍历结束后，若是 min ！= i，证明最小的值不是elem[i],交换elem[min]和elem[i]的位置。若min=i，证明elem[i]最小，不用交换。

第一种思路是每次遇见比elem[i]小就交换。第二种，先找出最小的再交换。

优化：每次遍历找到最小的元素和最大的元素，将最小和最大的分别放在数组的头和尾。

 

4.2 实现

 public static void selectSort(int[] array){
        if(array == null){
            return;
        }
        for(int i = 0;i<array.length;i++){
            for(int j = i+1;j<array.length;j++){
                if(array[i]>array[j]){  // 碰见比array[i]小的，就交换
                    int tmp = array[i];
                    array[i] = array[j];
                    array[j] = tmp;
                }
            }
        }
    }
    public static void selectSort2(int[] array){
        if(array == null){
            return;
        }
        for(int i= 0;i<array.length;i++){
            int min = i;
            for(int j =i+1;j<array.length;j++){  // 找到最小的元素，再交换
                if(array[j]<array[min]){
                    min = j;
                }
            }
            if(min != i){
                int tmp = array[min];
                array[min] = array[i];
                array[i] = tmp;
            }
        }
    }
//每一趟遍历找出最大的最小的，将其放在队列的尾部和头部
public static void selelctSort(int[] array){
        if(array == null){
            return;
        }
        for(int i = 0;i<=array.length/2;i++){
            int min = i;
            int max = i;
            for(int j = i+1;j<=array.length-1-i;j++){//每次在array[i,array.length-1-i]中找出最大和最小
                if(array[j]<array[min]){
                    min = j;  //找最小
                }
                if(array[j]>array[max]){
                    max = j;  // 找最大
                }
            }
            if(max == i && min ==array.length-1-i){
                swap(array,min,max);  //恰好最大的元素在队头，最小的元素在队尾，则可以直接交换队头和队尾元素。
            }else {
                swap(array,i,min); // 最小的放队头
                swap(array,array.length-1-i,max); // 最大的放队尾
            }
        }

    }
    public static void swap(int[] array,int left,int right){
        int tmp = array[left];
        array[left] = array[right];
        array[right] = tmp;
    }

4.3 性能分析

时间复杂度

空间复杂度
稳定性不稳定

五、堆排序

5.1 原理

先建立一个大根堆，交换堆顶元素和最后一个元素的位置。交换完后，最大的元素已经在队尾，再次建立大根堆时不用再考虑最后一个元素。用 [0,end] 表示需要排序的元素，每把大根堆的堆顶元素和最后一个元素交换结束后，end减一，直到end=0，证明已经排序结束。

5.2 实现

public static void heapSort(int[] array){
        if(array == null){
            return;
        }
        int end = array.length-1; //标记结束位置的下标
        while(end>=0){
            int parent = (end-1)/2;
            while(parent>=0){
                shiftDown(array,parent,end);
                parent--;
            }
            int tmp = array[0];
            array[0] = array[end];
            array[end] = tmp;
            end--;
        }
    }
    public static void shiftDown(int[] array,int parent,int end){
        int child = parent*2+1;
        while(child <= end){
            if(child+1<=end && array[child]<array[child+1]){
                child++;
            }
            if(array[child]>array[parent]){
                int tmp = array[child];
                array[child] = array[parent];
                array[parent] = tmp;
            }
            parent = child;
            child = 2*parent+1;
        }
    }

5.3 性能分析

时间复杂度

空间复杂度
稳定性不稳定

六、冒泡排序

6.1 原理

如果第一个元素比第二个大，就交换这两个的位置。依次比较相邻位置的元素，

6.2 实现

public static void bubble(int[] array){
        if(array == null){
            return;
        }
        for(int i = 0;i<array.length-1;i++){
            System.out.printf("第%d趟比较",i+1);
            for(int j = 0;j<array.length-1-i;j++){
                if(array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
            System.out.println(Arrays.toString(array));
        }
    }
// 优化后
public static void bubbleSort(int[] array){
        if(array == null){
            return;
        }
        for(int i = 0;i<array.length-1;i++){
            boolean flag = false;
            System.out.printf("第%d趟比较",i+1);
            for(int j = 0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flag = true;
                }
            }
            System.out.println(Arrays.toString(array));
            if(! flag){
                break;
            }
        }
    }

6.3 性能分析

时间复杂度

空间复杂度
稳定性稳定

七、快速排序

7.1 快速排序的递归实现

7.1.1 原理

step1：从待排序区间中选择一个数，作为基准值(pivot).

step2:Partiton:遍历整个待排序区间，将比基准值pivot小的放到基准值的左边，将比基准值pivot大的放在基准值的右边。

step3：采用分治思想，对左右两个区间按照同样的方式处理，直到区间的长度小于等于1.

7.1.2  挖坑法

    public static void quickSort(int[] array){
        if(array == null){
            return;
        }
        quick(array,0,array.length-1);
    }
    public static void quick(int[] array,int left,int right){
        if(right-left<=0){
            return;
        }
        int privot = partition(array,left,right);
        quick(array,left,privot-1);
        quick(array,privot+1,right);

    }
    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];
            if(left == right){
                array[left] = tmp;
            }
        }
        return left;
    }

7.1.3  hoare法

    public static void quickSort(int[] array){
        if(array == null){
            return;
        }
        quick(array,0,array.length-1);
    }
    public static void quick(int[] array,int left,int right){
        if(right-left<=0){
            return;
        }
        int privot = hoarePartition(array,left,right);
        quick(array,left,privot-1);
        quick(array,privot+1,right);

    }
    public static int hoarePartition(int[] array,int left,int right){
        int key = left;
        while(left<right){
            while(left<right && array[right]>=array[key]){
                right--;
            }
            while(left<right && array[left]<=array[key]){
                left++;
            }
            if(left != right){
                int tmp = array[left];
                array[left] = array[right];
                array[right] = tmp;
            }
            if(left == right){
                int tmp = array[left];
                array[left] = array[key];
                array[key] = tmp;
            }
        }
        return left;
    }

7.1.4 优化

优化分为三个方面：

①选择基准值的优化：主要是想将待排序序列均匀的分割，越均匀，速度越快。

     选择左边或者右边：若最小的数在最左边，将其作为基准值，第一趟排序中数组里的元素几乎没交换，还处于无序状态。

     随机选取：不是特别好，有可能产生的随机数是第二小的，第一趟排序下来就只交换了一下。

     几数取中法：以三数取中为例，先调换元素位置使其满足array[left]<=array[mid]<=array[right]，然后调换array[mid]和array[left]的位置。

②partiton过程中把和基准值相等的数也选择出来。

③当递归执行到一个区间时，进行直接插入排序。

    public static void midtofirst(int[] array,int left,int right){
        int mid = (left+right)/2;
        while(true){
            if(array[mid]<array[left]){
                int tmp = array[mid];
                array[mid] = array[left];
                array[left] = tmp;
            }
            if(array[mid] > array[right]){
                int tmp = array[mid];
                array[mid] = array[right];
                array[right] = tmp;

            }
            if(array[left]>array[right]){
                int tmp =array[left];
                array[left] = array[right];
                array[right] = tmp;
            }
            if(array[left]<=array[mid] && array[mid]<=array[right]){
                break;
            }
           // 满足array[left]<= array[mid]<=array[right]
            // 交换array[left] 和array[mid]
            int tmp = array[left];
            array[left] = array[mid];
            array[mid] = tmp;
        }
  // 使用
     public static void quickdiedai(int[] array,int left,int right){
        if(right-left<=0){
            return;
        }
        midtofirst(array,left,right);
        int privot = hoarepartiton(array,left,right);
        quickdiedai(array,left,privot-1);
        quickdiedai(array,privot+1,right);

    }

7.2 非递归实现

采用栈将每次的left和right都存储起来。注意每次的pop和push时需要与left和right对应起来。

    public static void quickNull(int[] array){
        if(array == null){
            return;
        }
        Stack<Integer> stack = new Stack<>();
        stack.push(0);
        stack.push(array.length-1);
        while(! stack.isEmpty()){
            int right = stack.pop();
            int left = stack.pop();
            int privot = partition(array,left,right);
            if(privot-left>1){
                stack.push(left);
                stack.push(privot-1);
            }
            if(right-privot>1){
                stack.push(privot+1);
                stack.push(right);
            }
        }
    }

7.3 性能分析

时间复杂度

空间复杂度
稳定性不稳定

 7.4 总结

step1：在待排序区间选择一个基准值

           选择左边或右边、随机选取、几数取中法

step2：做partition，使得左边的数小于privot，右边的数大于privot。

             hoare、挖坑

step3：分治处理左右两个小区间，直到小区间数目小于一个阈值，使用插入排序。

八、归并排序

8.1 原理

建立在归并操作上的一种有效的排序算法。先将每个子序列排序，再将有序子序列合并成一个有序表。若将两个有序表合并成一个有序表，称为二路归并。

8.2 归并排序的递归实现

    public static void mergeSort(int[] array){
        if(array == null){
            return;
        }
        mergesortdigui(array,0,array.length-1);
    }
    public static void mergesortdigui(int[] array,int left,int right){
        if(right - left<=0){
            return;
        }
        int mid = (left+right)/2;
        mergesortdigui(array,left,mid);
        mergesortdigui(array,mid+1,right);
        merge(array,left,mid,right);
    }
    public static void merge(int[] array,int left,int mid,int right){
        int[] elem = new int[right-left+1];
        int k = 0;
        int s1 = left;
        int e1 = mid;
        int s2 = mid+1;
        int e2 = right;
        // 这种情况是s1和s2没有越界的情况
        while(s1<=e1 && s2<=e2){
            if(array[s1]<array[s2]){
                elem[k++] = array[s1++];
            }else{
                elem[k++] = array[s2++];
            }
        }
        // s1没有越界了
        while(s1<=e1){
            elem[k++] = array[s1++];
        }
        // s2没有越界
        while(s2<=e2){
            elem[k++] = array[s2++];
        }
        for (int i = 0; i < elem.length; i++) {
            array[i+left] = elem[i];
        }
    }

8.3 归并排序的非递归实现

 public static void mergeNoRecurrence(int[] array){
        if(array == null){
            return;
        }
        for(int gap =1;gap<array.length;gap*=2){
            mergefeidiedai(array,gap);
        }
    }
    public static void mergefeidiedai(int[] array,int gap){
        int s1 = 0;
        int e1 = s1+gap-1;
        int s2 = e1+1;
        int e2 = s2+gap-1 <=array.length-1?(s2+gap-1):array.length-1;
        int[] elem = new int[array.length];
        int k = 0;
        while(s2 <= array.length-1){
            while(s1<=e1 && s2<=e2){
                if(array[s1]<=array[s2]){
                    elem[k++] = array[s1++];
                }else{
                    elem[k++] = array[s2++];
                }
            }
            while(s1<=e1){
                elem[k++] = array[s1++];
            }
            while(s2<=e2){
                elem[k++] = array[s2++];
            }
            // 结束后，s2和e2都指向s2+1,要不然都跳不出上面的循环
            s1 = s2;
            e1 = s1+gap-1;
            s2 = e1+1;
            e2 = s2+gap-1 <=array.length-1?(s2+gap-1):array.length-1;
        }
        // 第一段是肯定会有的，第二段有可能没有
        // 如果第二段没有，就会跳出循环
        // 此处也不能用e1,因为e1也有可能超过数组长度
        while(s1<=array.length-1){
            elem[k++] = elem[s1++];
        }
        for(int i =0;i<elem.length;i++){
            array[i] = elem[i];
        }
    }

8.4 性能分析

时间复杂度

空间复杂度
稳定性稳定

 九、排序总结

排序算法时间复杂度(最坏)空间复杂度稳定性
冒泡排序

  

稳定
插入排序

  

稳定
选择排序

  

不稳定
希尔排序

  

不稳定
堆排序不稳定
快速排序不稳定
归并排序

 

稳定

刘减减
关注
专栏目录
Python算法Lesson1:Python算法入门(适合萌新)
theoxiong的博客
08-23 367
算法，是解决问题的一组有限步骤或规则，用来描述如何从初始状态经过若干步骤，最终达到预期的目标。算法可以简单到计算两个数字之和，也可以复杂到在全球范围内寻找最优的物流路径。在计算机科学中，算法是一切计算的基础。每一个程序都可以被视为一个或多个算法的组合，这些算法指导计算机如何有效地处理数据，解决问题。例如，经典的算法问题包括：如何找到数组中的最大值？如何排序大量无序的数据？如何在迷宫中找到出口？每个问题都可以通过不同的算法来解决，效率与难度也各不相同。
Java面试：算法常用面试题汇总
m0_67537062的博客
04-16 1930
二分法查找（Binary Search）也称折半查找，是指当每次查询时，将数据分为前后两部分，再用中值和待搜索的值进行比较，如果搜索的值大于中值，则使用同样的方式（二分法）向后搜索，反之则向前搜索，直到搜索结束为止。二分法使用的时候需要注意：二分法只适用于有序的数据，也就是说，数据必须是从小到大，或是从大到小排序的。解释// 二分法查找System.out.println("元素第一次出现的位置（从0开始）：" + binaryResult);/**
Lesson3：排序与CTR预估问题
u014765410的博客
03-27 244
一、给出CTR背景知识 1、在online advertising领域，其收费方式有以下几种： CTR即click through rate，其计算公式如下： 通过预测每只广告的CTR，我们可以评估向用户推荐那些“广告”最赚钱，在实际场景中，对“广告的评估”不仅仅会使用CTR，可能会结合多个指标综合考虑，比如：可能会用CTR * price来评估广告的推荐 会赚多少钱。这是因为，有些广告，cl...
Lesson 1：优先级队列(堆)
weixin_44258092的博客
01-06 586
首先分享了创建大根堆、添加元素、删除堆顶元素、堆排序、topK问题、和最小的K对数字的实现算法.然后结合源码分析PriorityQueue中扩容方式,最后分享了如何利用PriorityQueue建立一个大根堆.
COMP397-W2021-Lesson2a-main-main.rar
10-09
7. **数据结构与算法**：如果是编程作业，可能涉及到特定的数据结构（如数组、链表、树、图）和算法（排序、搜索等），学习者需要掌握这些基础知识。 8. **问题解决**：通过解压缩并分析源码，学习者将锻炼解决问题...
[FreeCodeCamp笔记] Python 数据结构和算法1 二分搜索 Binary Search
juwikuang的专栏
10-18 2541
我以前学过数据结构和算法（data structure and algorithms. 现在普遍简称DSA），当时用的Robert Sedgewick的coursera课程。这位大神写的《算法（第四版）》，是算法的经典教材，可惜这本书900页，我直接被吓跑了。而coursera课程用的是java，我又不会java，所以课后习题做的异常艰苦。 这几天，我又想学一下数据结构和算法，但是我决定用python学。其实我也会c++和c#，但是python显然是最简单易用的语言，使用python可以节省很多时间。于是，
【数据结构】排序算法——Lesson2
小羊的博客
07-23 3289
归并、计数排序
决策树的三种常见算法
热门推荐
huxiyan450的博客
08-11 1万+
决策树用途&组成构造算法1. 特征选择metricID3：信息增益定义使用场景例子缺点C4.5: 信息增益比定义连续数值特征的处理（转化为二分类寻找阈值的问题）解决过拟合问题：剪枝问题CART(Classification And Regression Tree):定义使用场景后剪枝：基于代价复杂度优劣总结比较算法分析适用场景问题过拟合类别不均衡实现 用途&组成 决策树是一个监督学习模型，可用于分类和回归，它是一个由内节点和叶节点构成的树型结构。每个内节点对应了一个关于某种特征的测试（Dec
2.常用排序算法
qq_44805237的博客
06-21 102
13/100 发布文章 加粗倾斜下划线删除线h1h2h3颜色块引用有序无序链接代码段插入公式表格图表图像水平线视频摘要缩进目录撤消重做
Hive SQL进阶：掌握这些SQL查询技巧，让你的数据报告更加精准和高效！
击水三千里的专栏
08-05 953
这份文档提供了一系列的SQL查询示例，用于解决数据分析中的常见问题，如用户活跃度、留存率、销售统计等。通过这些示例，用户可以学习如何使用SQL进行高效的数据查询和分析。
常用排序算法、二
he_qiao_2010的专栏
05-12 1288
排序算法中的几个基本概念： 1.内部排序和外部排序 内部排序：将所有的排序记录都存储于计算机随机存储器中的排序过程； 外部排序：排序记录的数量过大，以致于不能将所有的排序记录一次性读入内存，因而在排序过程中还需对外存进行读取的过程。 2.稳定排序和不稳定排序 假设原排序序列：… R1, R2, …(排序键值KR1 = KR2) 稳定排序：排序之后,R1任然在R2的前面...R1,R
排序（用java实现）
2201_76124988的博客
11-05 994
排序排序的概念及引用排序的概念常见的排序算法常见排序算法的实现插入排序基本思想：直接插入排序希尔排序(缩小增量排序)选择排序基本思想：直接选择排序堆排序交换排序冒泡排序快速排序快速排序的优化快速排序非递归归并排序基本思想归并排序归并排序的非递归海量数据的排序问题排序算法复杂度及稳定性分析其他非基于比较排序选择题 排序的概念及引用 排序的概念 排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字记录，若经过排
交换排序与快速排序
h3286918168的博客
11-05 872
3、在走的过程中，若end遇到小于key的数，则停下，begin开始走，直到begin遇到一个大于key的 数时，将begin和right的内容交换，end再次开始走，如此进行下去，直到begin和end最终相遇，此 时将相遇点的内容与key交换即可。基本思想: 所谓交换，就是根据序列中元素值进行比较，根据比较结果对两个数据进行位置的相互交换序列中的位置，交换特点：将键值大的元素向序列尾部移动或将键值小的元素向序列的前部移动。4.此时key的左边都是小于key的数，key的右边都是大于key的数。
100种算法【Python版】第49篇——桶排序
AnFany
11-05 139
100种算法【Python版】第49篇——桶排序
基数排序算法
a921876874的博客
11-05 890
基数排序算法
100种算法【Python版】第50篇——Tim Sort
AnFany
11-05 130
100种算法【Python版】第50篇——Tim Sort
【手撕排序1】希尔排序(直接插入排序)
2401_83251330的博客
11-06 402
🌟在上一节我们实现了链式二叉树，如果感兴趣的小伙伴，可以阅读我的上一篇文章:>二叉树，从这节开始小编带大家实现常见的排序算法。
Java中查找与排序算法探究
小金的博客
11-05 554
java常见的查询与排序算法详解
java实现冒泡排序算法
licy__的博客
11-08 464
冒泡排序的基本思想是通过多次遍历待排序的数组，每次比较相邻的两个元素，如果它们的顺序错误就交换它们的位置。这个过程会使得每一轮遍历后最大的元素“浮”到数组的末尾。冒泡排序的空间复杂度为 O(1)O(1)，因为它是一个原地排序算法，不需要额外的存储空间。
排序算法基础
最新发布
安祝老师的博客
11-08 678
在计算机科学中，排序算法是数据处理和组织的核心工具之一。从日常应用到编程竞赛，排序算法广泛应用于对数据的有效管理和处理。排序算法可以帮助我们更快地找到目标数据、优化其他算法的效率，并为各种高级算法打下坚实基础。本文目标是帮助读者理解排序算法的基本概念和用途，并为后续排序算法的学习奠定基础。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

刘减减

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

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

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

打赏作者

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

抵扣说明：

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

余额充值