Algorithms-2.2 Mergesort 归并排序

最新推荐文章于 2023-12-11 10:45:47 发布
最新推荐文章于 2023-12-11 10:45:47 发布
阅读量184 收藏
点赞数
分类专栏： Bootcamp 文章标签： java 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Joyji99/article/details/118941360
版权

Mergesort

1 归并排序 Mergesort

在这里插入图片描述

1.1 原地归并在这里插入图片描述

  • 抽象的“原位归并”
  • 需要一个辅助数组记录数据，i和j比较，小的放回原数组，index右移1位，两个子数组继续比较；如果两边数组值一样，取左边数组的
package Chapter02;

public class Merge {
    private static void merge(Comparable[] a,Comparable[] aux,int lo,int mid,int hi){
        assert Riqi.isSorted(a,lo,mid); //precondition: a[lo...mid]   sorted
        assert Riqi.isSorted(a,mid+1,hi); //precondition: a[mid+1...hi]   sorted

        //copy
        for (int k = lo; k <= hi; k++) {
            aux[k] = a[k];

        //merge
        int i = lo, j = mid+1;
            for (int m = lo; m <= hi ; m++) {
                if      (i > mid)                     a[m] = aux[j++];//如果i走到边界，说明左边子数组已经全部移上去了，就把j移上去
                else if (j > hi)                      a[m] = aux[i++];//如果j走到边界，说明右边子数组已经全部移上去了，就把i移上去
                else if (Riqi.less(aux[j],aux[i]))    a[m] = aux[j++];//将j移到原数组，然后j自增
                else                                  a[m] = aux[i++];//将i移到原数组，然后i自增
            }


        assert Riqi.isSorted(a,lo,hi); //precondition: a[lo...hi]   sorted

        }
    }
}

assert

  • assert后跟boolean：在最后表明做了什么，在前面表明要做什么
  • assert默认是禁用的

1.2 自顶向下的归并排序

package Chapter02;

import java.util.Arrays;

public class Merge {
    private static void merge(Comparable[] a,Comparable[] aux,int lo,int mid,int hi){
        assert Riqi.isSorted(a,lo,mid); //precondition: a[lo...mid]   sorted
        assert Riqi.isSorted(a,mid+1,hi); //precondition: a[mid+1...hi]   sorted

        //copy
        for (int k = lo; k <= hi; k++) {
            aux[k] = a[k];
        }

        //merge
        int i = lo, j = mid+1;
        for (int m = lo; m <= hi ; m++) {
            if      (i > mid)                     a[m] = aux[j++];//如果i走到边界，说明左边子数组已经全部移上去了，就把j移上去
            else if (j > hi)                      a[m] = aux[i++];//如果j走到边界，说明右边子数组已经全部移上去了，就把i移上去
            else if (Riqi.less(aux[j],aux[i]))    a[m] = aux[j++];//将j移到原数组，然后j自增
            else                                  a[m] = aux[i++];//将i移到原数组，然后i自增
            }


        assert Riqi.isSorted(a,lo,hi); //precondition: a[lo...hi]   sorted

    }

    //不要将辅助数组在这里创建，会多出许多额外的小数组的花费
    private static void sort(Comparable[] a,Comparable[] aux,int lo,int hi){
        if (hi <= lo) return;//先检查下标，如果检查不通过，后续不运行   false则继续运行后面代码
        int mid = lo + (hi - lo) / 2;
        //反复套娃，直到最小的数组长度变为2
        sort(a,aux,lo,mid); //左半边排序
        sort(a,aux,mid+1,hi);//右半边排序
        merge(a,aux,lo,mid,hi); //归并结果
    }

    private static void sort(Comparable[] a){
        Comparable[] aux = new Comparable[a.length];
        sort(a,aux,0,a.length-1);
    }

    public static void main(String[] args) {
        Comparable[] a = {32,23,1,134,5,23,856,54,90};
        sort(a);
        System.out.println(Arrays.toString(a)); // [1, 5, 23, 23, 32, 54, 90, 134, 856]

    }
}
  • 如果执行了return语句，那么后面的语句将会不执行
    在这里插入图片描述
  • 把原数组不断对半分，直到变成两两一组

1.3 复杂度

在这里插入图片描述

  • 在数据量巨大的情况下，归并排序与插入排序相比具有优越性
  • 合并时最多需要比较N次（比一次，放回原数组一个元素）：如果左右没有一边提前排完，就需要N次比较
  • 数组访问次数：merge所需次数是6N（从a拷贝到aux算2次数组访问） —> 2N次用来复制，2N次用来将排好序的元素移动回去，另外最多比较2N次
    在这里插入图片描述
1.3.1 图示法
  • 假设N=2n
    在这里插入图片描述
  • 2n需要不断除以2，共除log2N次，即log2N层
  • 每层归并都需要比较N次，将所有层相加即为总比较次数
1.3.2 代数法

在这里插入图片描述

1.3.2 数学归纳法

在这里插入图片描述

  • 归纳假设
  • log2(2N) = log2(N) + log2(2) = log2(N) + 1

1.4 内存占用

在这里插入图片描述

  • 辅助数组需要占内存一半的空间，所以不能实现真正的原地排序
  • 希尔排序、插入排序等是真正的原地排序

1.5 归并排序的改进

1.5.1 引入插入排序
  • 对于小的数组采用归并排序，不停递归、调用方法使性能损失
  • 可以对小于某个数值的小数组采用插入排序
    在这里插入图片描述
private static final int CUTOFF = 7; //设置判断是否使用插入排序的初始值

    //不要将辅助数组在这里创建，会多出许多额外的小数组的花费
    private static void sort(Comparable[] a,Comparable[] aux,int lo,int hi){
        //if (hi <= lo) return;//先检查下标，如果检查不通过，后续不运行   false则继续运行后面代码
        //小数组使用插入排序
        if(hi <= lo + CUTOFF - 1){  //末项 - 首项 <= 6   数组长度小于7
            Insertion.sort(a, lo, hi);
            return;}

        int mid = lo + (hi - lo) / 2;
        //反复套娃，直到最小的数组长度变为2
        sort(a,aux,lo,mid); //左半边排序
        sort(a,aux,mid+1,hi);//右半边排序
        merge(a,aux,lo,mid,hi); //归并结果
    }
1.5.2 子数组有序则直接复制

在这里插入图片描述

  • 检测待归并的两个子数组是否已经有序，如果有序，则可跳过此轮归并
  • 只需检测前一半最大的数是否小于后一半最小的数
    private static void sort(Comparable[] a,Comparable[] aux,int lo,int hi){
        if (hi <= lo) return;//先检查下标，如果检查不通过，后续不运行   false则继续运行后面代码
        int mid = lo + (hi - lo) / 2;
        //反复套娃，直到最小的数组长度变为2
        sort(a,aux,lo,mid); //左半边排序
        sort(a,aux,mid+1,hi);//右半边排序
        if (!Riqi.less(a[mid+1],a[mid])) return;//如果数组已经有序则直接复制，不再merge    使用！非可以将等于包含进来
        merge(a,aux,lo,mid,hi); //归并结果
    }
1.5.3 节省拷贝到辅助数组的时间
  • 通过再递归中交换参数来避免每次归并时都要复制数组到辅助数组
  • 每轮递归时，转换原数组和辅助数组的角色
    在这里插入图片描述
package Chapter02;

import java.util.Arrays;

public class Merge {
    private static void merge(Comparable[] a,Comparable[] aux,int lo,int mid,int hi){
        assert Riqi.isSorted(a,lo,mid); //precondition: a[lo...mid]   sorted
        assert Riqi.isSorted(a,mid+1,hi); //precondition: a[mid+1...hi]   sorted

        int i = lo, j = mid+1;
        //将a数组归并到aux数组
        for (int m = lo; m <= hi ; m++) {
            if      (i > mid)                     aux[m] = a[j++];//如果i走到边界，说明左边子数组已经全部移上去了，就把j移上去
            else if (j > hi)                      aux[m] = a[i++];//如果j走到边界，说明右边子数组已经全部移上去了，就把i移上去
            else if (Riqi.less(a[j],a[i]))        aux[m] = a[j++];//将j移到原数组，然后j自增
            else                                  aux[m] = a[i++];//将i移到原数组，然后i自增
        }

        assert Riqi.isSorted(a,lo,hi); //precondition: a[lo...hi]   sorted

    }

    private static final int CUTOFF = 7; //设置判断是否使用插入排序的初始值

    //不要将辅助数组在这里创建，会多出许多额外的小数组的花费
    private static void sort(Comparable[] a,Comparable[] aux,int lo,int hi){
 
        if (hi <= lo) return;
        int mid = lo + (hi - lo) / 2;
        sort(aux,a,lo,mid); //左半边排序
        sort(aux,a,mid+1,hi);//右半边排序
        merge(a,aux,lo,mid,hi); //归并  转换a和aux的角色
    }

    private static void sort(Comparable[] a){
        Comparable[] aux = a.clone();
        sort(a,aux,0,a.length-1);
    }

    public static void main(String[] args) {
        Comparable[] a = {32,23,1,134,5,23,856,54,90};
        sort(a);
        System.out.println(Arrays.toString(a)); // [1, 5, 23, 23, 32, 54, 90, 134, 856]

    }
}

2 自底向上的归并排序 bottom-up mergesort

在这里插入图片描述

  • 能够遍历整个序列且不需要递归
package Chapter02;

import javax.swing.*;

public class MergeBU {
    //归并所需的辅助数组
    private static Comparable[] aux;

    private static void merge(Comparable[] a,int lo,int mid,int hi){
        assert Riqi.isSorted(a,lo,mid); //precondition: a[lo...mid]   sorted
        assert Riqi.isSorted(a,mid+1,hi); //precondition: a[mid+1...hi]   sorted

        //copy
        for (int k = lo; k <= hi; k++) {
            aux[k] = a[k];
        }

        //merge
        int i = lo, j = mid+1;
        for (int m = lo; m <= hi ; m++) {
            if      (i > mid)                     a[m] = aux[j++];//如果i走到边界，说明左边子数组已经全部移上去了，就把j移上去
            else if (j > hi)                      a[m] = aux[i++];//如果j走到边界，说明右边子数组已经全部移上去了，就把i移上去
            else if (Riqi.less(aux[j],aux[i]))    a[m] = aux[j++];//将j移到原数组，然后j自增
            else                                  a[m] = aux[i++];//将i移到原数组，然后i自增
        }

        assert Riqi.isSorted(a,lo,hi); //precondition: a[lo...hi]   sorted

    }

    public static void sort(Comparable[] a){
        //进行lgN次两两归并
        int N = a.length;
        Comparable[] aux = new Comparable[N];
        for (int sz = 1; sz < N; sz = sz+sz) {//外循环：子数组长度每轮翻倍
            //内循环：每个子数组归并
            for (int lo = 0; lo < N-sz; lo += sz+sz) { //sz为子数组大小  lo = lo+sz+sz 跳到下一个子数组起始位置
                merge(a,lo,lo+sz-1,Math.min(lo+sz+sz-1,N-1)); //最末子数组也许长度不够sz，长度不够则选数组最后一个元素
            }
        }
    }
}

在这里插入图片描述

  • 时间复杂度为logN，而每一轮需要进行N次比较，因此总复杂度为NlogN

3 排序算法的复杂度 sorting complexity

在这里插入图片描述

  • lower bound就是要找一个最小的比较次数；optimal algorithm是lower bound与upper bound相等时
    在这里插入图片描述
    在这里插入图片描述
  • 全排列这棵树至少有N! 个叶子结点，因为N个不同的主键（元素）会有N! 种不同的排列
  • 二叉树的组合学性质是高度为h的树最多只可能有2h个叶子结点，此时该树为完全树（每一层每个点都有两个叉）
    在这里插入图片描述
  • 因此树的高度大于等于log2(N!)，根据Stirling公式，正比于NlgN，即排序算法复杂度的下限
    在这里插入图片描述
    在这里插入图片描述
  • 归并排序时间复杂度最优，但空间复杂度不是最优
  • 以上证明都基于所有元素不同且完全打乱的前提
    在这里插入图片描述

4 比较器 comparators

在这里插入图片描述

  • 比较器接口：对同一数据的不同排序
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
package Chapter02;

import java.util.Comparator;

public class Student {

    //原码见 algs4/Selection
    public static void sort(Object[] a, Comparator comparator){
        int N = a.length;
        for (int i = 0; i < N; i++) {
            for (int j = i; j >0 && Riqi.less(comparator,a[j],a[j-1]); j--) {
                Selection.exch(a,j,j-1);
            }
        }
    }

    //按照不同的键对同一组数据进行排序
    public static final Comparator<Student> BY_NAME = new ByName();
    public static final Comparator<Student> BY_SECTION = new BySection();
    private final String name;//这里的对象要赋值，否则带final报错
    private final int section;


    private static class ByName implements Comparator<Student>{
        public int compare(Student v,Student w){
            return v.name.compareTo(w.name);
        }
    }

    private static class BySection implements Comparator<Student>{
        public int compare(Student v,Student w){
            return v.section - w.section; //这里不会溢出
        }
    }

}

在这里插入图片描述
在这里插入图片描述

  • 根据极坐标排序
  • 用几何方法非常复杂，可以用counterclockwise
    在这里插入图片描述
  • 源码见algs4 --> Point2D
    在这里插入图片描述

5 稳定性 stability

在这里插入图片描述

  • 不是所有排序都能在按section排列的情况下，name仍然按顺序排，这就是stability
  • A stable sort preserves the relative order of items with equal keys (一个稳定的排列是指拥有相同关键字的记录保留其相对顺序)
  • 插入排序和归并排序是稳定的，选择排序和希尔排序不是
    在这里插入图片描述
  • 插入排序是稳定的，因为拥有相同值的两个元素不会交换，即不会越过对方
    在这里插入图片描述
    在这里插入图片描述
  • 长距离交换使得相同值被越过
    在这里插入图片描述
    在这里插入图片描述
  • 归并排序遇到相同值总取左边的，不会打乱顺序
不乖不乖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
algorithms-demo
03-19
"algorithms-demo"涵盖了排序（如冒泡排序、快速排序、归并排序）、搜索（如线性搜索、二分搜索）、图算法（如深度优先搜索、广度优先搜索）、最短路径算法（如Dijkstra算法、Floyd-Warshall算法）等多种经典算法的...
Sorting-algorithms-animation-Java:为7种不同的排序算法对动画进行排序
05-01
5. **归并排序**：归并排序是建立在归并操作上的一种有效的排序算法，采用了分治法策略。将待排序的序列分为两部分，分别进行排序，然后将两个有序序列合并成一个。时间复杂度为O(n log n)，空间复杂度为O(n)。 6. ...
归并排序 递归 非递归 原地 详解及优化效率分析
_
03-14 547
一文吃透 《归并排序》 归并排序递归非递归算法 merge算法及辅助空间优化 原地排序算法详解 运行效率分析 1、归并排序递归&非递归算法 递归 先划分，再合并 private void mergeByRecursion(int[] array,int begin,int end){ if(begin<end){ int mid = (begin+end)>>1...
归并排序 java实现
可控的事情要谨慎，不可控的事情要乐观。
10-03 142
参考资料：《算法》第四版 一、核心思想：分治 归并排序（Merge Sort）： 当我们要排序这样一个数组的时候，归并排序法首先将这个数组分成一半。如图： 然后想办法把左边的数组给排序，右边的数组给排序，之后呢再将它们归并起来。当然了当我们对左边的数组和右边的素组进行排序的时候，再分别将左边的数组和右边的数组分成一半，然后对每一个部分先排序，再归并。 如图： 对于上面的每一个部分呢，我们依然...
数组的归并排序（不使用辅助空间，循环）
SYSUprophet
07-13 3725
//data[begin,mid)和data[mid,end)两部分交换位置 void RingShift(int* data, int begin, int mid, int end); void MergeSort(int* data, int length) { if(data == NULL || length <= 0) return; //steps为步长，将data[]分
《大话数据结构》第9章 排序 9.8 归并排序（下）
weixin_33957648的博客
04-26 88
9.8.3 归并排序复杂度分析         我们来分析一下归并排序的时间复杂度，一趟归并需要将SR[1]～SR[n]中相邻的长度为h的有序序列进行两两归并。并将结果放到TR1[1]～TR1[n]中，这需要将待排序序列中的所有记录扫描一遍，因此耗费O(n)时间，而由完全二叉树的深度可知，整个归并排序需要进行⌈log2n⌉趟，因此，总的时间复杂度为O(nlogn)，而且这是归并排序算法中最好...
排序算法——归并排序与快速排序
奋斗吧_-小青年
04-25 565
首先，二者都运用了递归和分治的两种重要思想。在这里递归就不做详细介绍。 分治：顾名思义，分而治之，这是在排序中我们非常常见的一种思想，同时也是在其他场景乃至日常生活的优秀解题方法。当我们遇到一个大的难题无从下手时，我们往往都会将其分成几个小块，当我们处理好每个小模块问题后，将其合并，大的问题便能够的以解决。同样，在我们处理排序问题时，也能充分利用分治思想来提高性能。 那么我们先来总结归并排序 归并排序 归并排序的思想其实很简单，总共分为两步，分与治。 当我们面对一个很大的数组时，用以往学过的冒泡，插入，选
Machine-Learning-Algorithms-master 配套数据集及源代码
01-02
Machine_Learning_Algorithms-master，Machine_Learning_Algorithms-master 配套数据集及源代码 Machine_Learning_Algorithms-master，Machine_Learning_Algorithms-master 配套数据集及源代码
js-odd-even-mergesort：用于JavaScript的Batcher奇偶合并排序算法
02-23
BatcherJavaScript奇偶合并排序算法。 参见 。 父母是 。 import { whole } from '@aureooms/js-odd-even-mergesort' ; import { list } from '@aureooms/js-itertools' ; import { increasing } from '@aureooms/...
eight-sorting-algorithms-master
11-07
本篇将详细介绍"八大排序算法"，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序和计数排序。 1. **冒泡排序(Bubble Sort)** 冒泡排序是最简单的排序算法之一。它通过不断比较相邻元素并...
排序-归并排序MergeSort
Passer-Go
05-27 566
1.归并排序简介 归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列； 即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 2.归并操作 归并操作(merge)，也叫归并算法，指的是将两个顺序序列合并成一个顺序序列的方法。 如　设有数列{6，202，100，301，38，8，1} 初始状态：6,202,100,301,38,8，
Java归并排序
最新发布
qq_38875964的博客
12-11 1946
归并排序（Merge Sort）是应用分治思想的一个典型例子。把一个待排序序列拆分为两个子序列，分别对两个子序列排序，子序列排序时也采用相同的方法，直至拆分后的两个子序列都是有序的，即长度为1的序列天然有序，这时停止拆分，将两个有序的子序列归并为一个更大的有序序列，与之前拆分时的路径相反，不断的归并有序子序列，最终归并为一个序列。这种将两个有序序列归并为一个有序序列的操作称为二路归并。
归并排序java（内附超详解图文讲解）
Javascript_tsj的博客
03-18 6254
归并排序介绍:归并排序(MERGE-SORT)是利用归并的思想实现的排序方法，该算法采用经典的分治(divide- and-conquer)策略(分治法将问题分(divide)成一-些 小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。 归并排序思想示意图1-基本思想: 归并排序思想示意图2-合并相邻有序子序列: 再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后- -次合并，要将[4,5,7,8]和[1
归并排序算法（java实现）
热门推荐
qq_45954420的博客
03-10 1万+
基本思想 归并排序是由递归实现的，主要是分而治之的思想，也就是通过将问题分解成多个容易求解的局部性小问题来解开原本的问题的技巧。 归并排序在合并两个已排序数组时，如果遇到了相同的元素，只要保证前半部分数组优先于后半部分数组， 相同元素的顺序就不会颠倒。所以归并排序属于稳定的排序算法。 每次分别排左半边和右半边，不断递归调用自己，直到只有一个元素递归结束，开始回溯，调用 merge 函数，合并两个有序序列，再合并的时候每次给末尾追上一个最大 int 这样就不怕最后一位的数字不会被排序。 归并排序的效率
JAVA编程----归并排序
m0_64148419的博客
12-22 1626
归并排序（Merge sort）是建立在归并操作上的一种有效、稳定的排序算法，该算法是采用分治法(Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
JAVA实现归并排序
QQ719271879的博客
11-23 2226
用Java语言实现归并排序算法
归并排序详解(Java语言描述 萌新向)
分享点点滴滴的知识~
11-04 1135
归并排序详解，简单易懂，喜欢就赶紧收藏吧~
Java排序算法（一）——归并排序
rocky的编程随记
09-10 5238
介绍 归并排序（Merge Sort）是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。其排序的速度仅次于快速排序，时间复杂度O(n log n)。 Java代码实现 /** * 归并排序 * @author rocky * @date 2021/9/10 10:34 */ public cl
归并排序java_Java经典排序算法之归并排序详解
sdajkjsad332的博客
12-08 526
一、归并排序 归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一
introduction to algorithms - hardcover edition
09-12
《算法导论》Hardcover版的引言（Introduction to Algorithms - Hardcover Edition）是一本经典的计算机科学教材。该版本不仅在内容上与平装版相同，还具有精美的硬皮封面，能够更好地保护书籍，并增添一份高质感和专业感。 首先，这本书是由Thomas H. Cormen等四位作者共同编写。他们是计算机科学领域的权威人物，在算法研究和教育方面具有丰富的经验。这本书的目的是为计算机科学专业的学生和从业人员提供系统而全面的算法知识，帮助他们深入理解和应用算法。 《算法导论》Hardcover版首先介绍了算法设计和分析的基础知识，包括分治法、贪婪算法、动态规划和回溯法等。接着，书中详细阐述了各种经典算法，如排序、图算法、字符串匹配、高级数据结构等。此外，书中还介绍了算法的优化技巧和应用领域，例如算法的并行化和近似算法。 与平装版相比，Hardcover版的封面更加美观，书页由高品质纸张制成，更加耐用。这使得读者在长时间研究和使用这本书时，能够更好地保存它的完整性和精美外观。此外，Hardcover版也更加适合作为礼品或收藏品，体现了读者对该书的重视和对算法学习的热爱。 总之，《算法导论》Hardcover版是一本内容丰富、思想深刻的算法教材，通过系统化的介绍和实例，帮助读者深入理解和应用各种算法。同时，Hardcover版的精美外观和耐用性也增强了读者在日常使用和收藏方面的满意度。无论是学习算法的新手还是资深专家，都能从这本书中获得极大的收益。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值