十大算法讲解

已于 2023-09-27 17:23:08 修改
阅读量79 收藏
点赞数
分类专栏： Java 文章标签： 算法 java 排序算法
于 2023-07-13 09:41:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huangshunjiu123/article/details/131694827
版权

十大排序算法原理及实现

1. 冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

  1. 算法步骤：
    ① 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
    ② 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
    ③ 针对所有的元素重复以上的步骤，除了最后一个。
    ④ 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
  2. 稳定排序、O(n^2)
  3. 实现
public class BubbleSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        for (int i = 1; i < arr.length; i++) {
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;

            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;

                    flag = false;
                }
            }

            if (flag) {
                break;
            }
        }
        return arr;
    }
}

2. 选择排序

选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

  1. 算法步骤：
    ① 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
    ② 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
    ③ 重复第二步，直到所有元素均排序完毕。
  2. 不稳定排序、O(n^2)
  3. 实现
public class SelectionSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        // 总共要经过 N-1 轮比较
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;

            // 每轮需要比较的次数 N-i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    // 记录目前能找到的最小值元素的下标
                    min = j;
                }
            }

            // 将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }

        }
        return arr;
    }
}

3. 插入排序

插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。

  1. 算法步骤：
    ① 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
    ② 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
  2. 稳定排序、O(n^2)
  3. 实现
public class InsertSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        // 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
        for (int i = 1; i < arr.length; i++) {

            // 记录要插入的数据
            int tmp = arr[i];

            // 从已经排序的序列最右边的开始比较，找到比其小的数
            int j = i;
            while (j > 0 && tmp < arr[j - 1]) {
                arr[j] = arr[j - 1];
                j--;
            }

            // 存在比其小的数，插入
            if (j != i) {
                arr[j] = tmp;
            }

        }
        return arr;
    }
}

4. 希尔排序

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；
希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。

  1. 算法步骤：
    ① 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
    ② 按增量序列个数 k，对序列进行 k 趟排序；
    ③ 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
  2. 不稳定排序、O(n^2)
  3. 实现
public static void shellSort(int[] arr) {
    int length = arr.length;
    int temp;
    for (int step = length / 2; step >= 1; step /= 2) {
        for (int i = step; i < length; i++) {
            temp = arr[i];
            int j = i - step;
            while (j >= 0 && arr[j] > temp) {
                arr[j + step] = arr[j];
                j -= step;
            }
            arr[j + step] = temp;
        }
    }
}

5. 归并排序

  1. 算法步骤：
    ①申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
    ②设定两个指针，最初位置分别为两个已经排序序列的起始位置；
    ③比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
    ④重复步骤 3 直到某一指针达到序列尾；
    ⑤将另一序列剩下的所有元素直接复制到合并序列尾。
  2. 稳定排序、O(nlogn)
  3. 实现
public class MergeSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        if (arr.length < 2) {
            return arr;
        }
        int middle = (int) Math.floor(arr.length / 2);

        int[] left = Arrays.copyOfRange(arr, 0, middle);
        int[] right = Arrays.copyOfRange(arr, middle, arr.length);

        return merge(sort(left), sort(right));
    }

    protected int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        int i = 0;
        while (left.length > 0 && right.length > 0) {
            if (left[0] <= right[0]) {
                result[i++] = left[0];
                left = Arrays.copyOfRange(left, 1, left.length);
            } else {
                result[i++] = right[0];
                right = Arrays.copyOfRange(right, 1, right.length);
            }
        }

        while (left.length > 0) {
            result[i++] = left[0];
            left = Arrays.copyOfRange(left, 1, left.length);
        }

        while (right.length > 0) {
            result[i++] = right[0];
            right = Arrays.copyOfRange(right, 1, right.length);
        }

        return result;
    }

}

6. 快速排序

  1. 算法步骤：
    ①从数列中挑出一个元素，称为 “基准”（pivot）;
    ②重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
    ③递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
  2. 不稳定排序、O(nlogn)
  3. 实现
public class QuickSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        return quickSort(arr, 0, arr.length - 1);
    }

    private int[] quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int partitionIndex = partition(arr, left, right);
            quickSort(arr, left, partitionIndex - 1);
            quickSort(arr, partitionIndex + 1, right);
        }
        return arr;
    }

    private int partition(int[] arr, int left, int right) {
        // 设定基准值（pivot）
        int pivot = left;
        int index = pivot + 1;
        for (int i = index; i <= right; i++) {
            if (arr[i] < arr[pivot]) {
                swap(arr, i, index);
                index++;
            }
        }
        swap(arr, pivot, index - 1);
        return index - 1;
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}

public class QuickSort {

    public static int getSortNum(int[] ary, int left, int right) {
        // 定义一个中枢值pivot，让其等于数组的左值，枢轴选定后永远不变，最终在中间，前小后大
        int pivot = ary[left];
        while (left < right) {
            // 看后面ary[right] > pivot比较，如果右边数组值大于中枢值，说明不需要调整位置，则让右值（right）自减1
            while (left < right && ary[right] >= pivot) {
                right--;  // 执行自减操作
            }
            // 如果上面循环不符合条件的，则说明右边数组的一个值，小于中枢值（pivot），则将其替换到左边数组中
            ary[left] = ary[right];
            // 看后面ary[left] < pivot比较，如果左边数组值小于中枢值，说明不需要调整位置，则让左值（left）自增1
            while (left < right && ary[left] <= pivot) {
                left++;  // 执行自增操作
            }
            // 如果上面循环不符合条件，则说明左边数组的一个值，大于中枢值（pivot），则将其替换到右边数组中
            ary[right] = ary[left];
        }
        // 最后将中枢值给自增后的左边数组的一个值中
        ary[left] = pivot;
        // 返回左边数组下标
        return left;
    }

    public static void quickSort(int[] ary, int left, int right) {
        // 定义中枢值
        int pivot;
        // 判断
        if (left < right) {
            // 根据方法得到了每次中枢值的位置
            pivot = getSortNum(ary, left, right);
            // 根据中枢值（pivot），来对左边数组进行递归调用快速排序
            quickSort(ary, left, pivot - 1);
            // 根据中枢值（pivot），来对右边数组进行递归调用快速排序
            quickSort(ary, pivot + 1, right);
        }
    }

    public static void main(String[] args) {
        int[] ary = {97, 58, 12, 88, 77, 22, 33, 44, 66, 22};
        quickSort(ary, 0, ary.length - 1);
        for (int i = 0; i < ary.length; i++) {
            if (i != ary.length - 1)
                System.out.print(ary[i] + ", ");
            else
                System.out.println(ary[i]);
        }
    }
}

7. 堆排序

  1. 算法步骤：
    ①创建一个堆 H[0……n-1]；
    ②把堆首（最大值）和堆尾互换；
    ③把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
  2. 不稳定排序、O(nlogn)
  3. 实现
public class HeapSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int len = arr.length;

        buildMaxHeap(arr, len);

        for (int i = len - 1; i > 0; i--) {
            swap(arr, 0, i);
            len--;
            heapify(arr, 0, len);
        }
        return arr;
    }

    private void buildMaxHeap(int[] arr, int len) {
        for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
            heapify(arr, i, len);
        }
    }

    private void heapify(int[] arr, int i, int len) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int largest = i;

        if (left < len && arr[left] > arr[largest]) {
            largest = left;
        }

        if (right < len && arr[right] > arr[largest]) {
            largest = right;
        }

        if (largest != i) {
            swap(arr, i, largest);
            heapify(arr, largest, len);
        }
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}

8. 计数排序

  1. 步骤
    （1）找出待排序的数组中最大和最小的元素
    （2）统计数组中每个值为i的元素出现的次数，存入数组C的第i项
    （3）对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
    （4）反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1
  2. 稳定排序、O(n+k)
  3. 实现方式
public class CountingSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int maxValue = getMaxValue(arr);

        return countingSort(arr, maxValue);
    }

    private int[] countingSort(int[] arr, int maxValue) {
        int bucketLen = maxValue + 1;
        int[] bucket = new int[bucketLen];

        for (int value : arr) {
            bucket[value]++;
        }

        int sortedIndex = 0;
        for (int j = 0; j < bucketLen; j++) {
            while (bucket[j] > 0) {
                arr[sortedIndex++] = j;
                bucket[j]--;
            }
        }
        return arr;
    }

    private int getMaxValue(int[] arr) {
        int maxValue = arr[0];
        for (int value : arr) {
            if (maxValue < value) {
                maxValue = value;
            }
        }
        return maxValue;
    }

}

9. 桶排序

  1. 稳定排序、O(n+k)
  2. 实现方式
public class BucketSort implements IArraySort {

    private static final InsertSort insertSort = new InsertSort();

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        return bucketSort(arr, 5);
    }

    private int[] bucketSort(int[] arr, int bucketSize) throws Exception {
        if (arr.length == 0) {
            return arr;
        }

        int minValue = arr[0];
        int maxValue = arr[0];
        for (int value : arr) {
            if (value < minValue) {
                minValue = value;
            } else if (value > maxValue) {
                maxValue = value;
            }
        }

        int bucketCount = (int) Math.floor((maxValue - minValue) / bucketSize) + 1;
        int[][] buckets = new int[bucketCount][0];

        // 利用映射函数将数据分配到各个桶中
        for (int i = 0; i < arr.length; i++) {
            int index = (int) Math.floor((arr[i] - minValue) / bucketSize);
            buckets[index] = arrAppend(buckets[index], arr[i]);
        }

        int arrIndex = 0;
        for (int[] bucket : buckets) {
            if (bucket.length <= 0) {
                continue;
            }
            // 对每个桶进行排序，这里使用了插入排序
            bucket = insertSort.sort(bucket);
            for (int value : bucket) {
                arr[arrIndex++] = value;
            }
        }

        return arr;
    }

    /**
     * 自动扩容，并保存数据
     *
     * @param arr
     * @param value
     */
    private int[] arrAppend(int[] arr, int value) {
        arr = Arrays.copyOf(arr, arr.length + 1);
        arr[arr.length - 1] = value;
        return arr;
    }

}

10. 基数排序

  1. 稳定排序、O(n*k)
  2. 实现方式
public class RadixSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int maxDigit = getMaxDigit(arr);
        return radixSort(arr, maxDigit);
    }

    /**
     * 获取最高位数
     */
    private int getMaxDigit(int[] arr) {
        int maxValue = getMaxValue(arr);
        return getNumLenght(maxValue);
    }

    private int getMaxValue(int[] arr) {
        int maxValue = arr[0];
        for (int value : arr) {
            if (maxValue < value) {
                maxValue = value;
            }
        }
        return maxValue;
    }

    protected int getNumLenght(long num) {
        if (num == 0) {
            return 1;
        }
        int lenght = 0;
        for (long temp = num; temp != 0; temp /= 10) {
            lenght++;
        }
        return lenght;
    }

    private int[] radixSort(int[] arr, int maxDigit) {
        int mod = 10;
        int dev = 1;

        for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
            // 考虑负数的情况，这里扩展一倍队列数，其中 [0-9]对应负数，[10-19]对应正数 (bucket + 10)
            int[][] counter = new int[mod * 2][0];

            for (int j = 0; j < arr.length; j++) {
                int bucket = ((arr[j] % mod) / dev) + mod;
                counter[bucket] = arrayAppend(counter[bucket], arr[j]);
            }

            int pos = 0;
            for (int[] bucket : counter) {
                for (int value : bucket) {
                    arr[pos++] = value;
                }
            }
        }

        return arr;
    }

    /**
     * 自动扩容，并保存数据
     *
     * @param arr
     * @param value
     */
    private int[] arrayAppend(int[] arr, int value) {
        arr = Arrays.copyOf(arr, arr.length + 1);
        arr[arr.length - 1] = value;
        return arr;
    }
}
HSJ.1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
大数据十大经典算法讲解.ppt
11-21
大数据十大经典算法讲解.ppt
大数据十大经典算法讲解优品文档.ppt
11-13
大数据十大经典算法讲解优品文档.ppt
常用十大算法
weixin_54950870的博客
09-25 6900
这里的讲解图主要使用的是尚硅谷韩顺平老师的图，请周知。 目录 二分查找（非递归） 分治算法 动态规划算法 KMP算法 贪心算法 普利姆（Prim）算法 克鲁斯卡尔（Kruskal）算法 迪杰斯特拉（Dijkstra）算法 弗洛伊德（Floyd）算法 骑士周游算法 总结 二分查找（非递归） 二分查找（非递归）算法：前面我们涉及的是递归实现二分查找算法。如今实现的是非递归的方式。同样，二分查找只适用于有序数列。二分查找的运行时间为对数时间O（log2n），即查找到需要的目标...
【C++】十大经典排序算法详解
hbqjzx的专栏
10-16 983
文章目录 排序算法总览 比较类排序算法 交换排序 一. 冒泡排序 算法思想 算法步骤 动图演示 代码实现 二. 快速排序 算法思想 算法步骤 动图演示 代码实现 三. 插入排序 算法思想 算法步骤 动图演示 代码实现 四. 希尔排序 算法思想 算法步骤 动图演示 代码实现 五. 选择
十大常用算法
雨思飞
12-23 2649
前言 最近在研究一些经常用到的东西想把它们做一个汇总，想了想用到最多的应该是排序算法，所以对排序算法做了个总结，并自己用C++实现了一下。 一、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。 线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。 0.2 算法复杂.
十大算法（动图讲解）❤️超详细！
卢卢在路上
09-02 1万+
您可能感兴趣的文章推荐 画解顺序表 画解链表 画解栈 画解队列 画解哈希表 画解二叉树 画解图 目录 零、算法概述 一、插入排序 二、冒泡...
十大经典排序算法
zhou_VisualStudio 的博客
11-15 1325
** 排序算法** 排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用下面的表概括： 排序算法 时间复杂度（平均） 时间复杂度（最好情况） 时间复杂度（最坏情况） 空间复杂度 排序方式 稳定性 冒泡排序 O(n²) O(n) O
机器学习常用十大算法
热门推荐
kw-home
06-17 1万+
机器学习常用10种算法
十大排序算法总结
NotLency的博客
12-26 507
排序算法
十大算法之普里姆算法
qq_44300280的博客
05-23 355
普里姆算法介绍
十大经典排序算法（C++实现）详细讲解
wxy2020915的博客
09-21 728
十大经典排序算法（C++实现）详细讲解
机器学习十大经典算法
十年以上架构设计经验，专注于软件架构和人工智能领域，对机器视觉、NLP、音视频等领域都有涉猎
07-27 3574
机器学习算法是计算机科学和人工智能领域的关键组成部分，它们用于从数据中学习模式并作出预测或做出决策。本文将为大家介绍十大经典机器学习算法，其中包括了线性回归、逻辑回归、支持向量机、朴素贝叶斯、决策树等算法，每种算法都在特定的领域发挥着巨大的价值。
大数据十大算法讲解学习教案.pptx
11-20
大数据十大算法讲解学习教案.pptx
大数据十大算法讲解PPT教案.pptx
10-04
大数据十大算法讲解PPT教案.pptx
大数据十大经典算法kNN讲解课件.ppt
07-13
大数据十大经典算法kNN讲解课件.ppt
代码随想录算法训练营第四十四天|70. 爬楼梯（进阶版）
qq_55999494的博客
05-22 237
INT_MAX这个条件是确保在利用dp[j - coins[i]]得到dp[j]的过程中，所使用的一定是更新过的dp[j - coins[i]]，防止dp[j - coins[i]]为未更新过的初始值，影响dp[j]的正常推导。因为无论排列和组合，求出的最小商品数都是相同的，所以可以先循环容量，再循环商品，反过来也行。多重背包问题，代取商品就是从1：m的数组，背包的容量就是n，由于是求方法数，所以递推公式为。此题是求最小的情况，也就是把背包装满所用的最小的商品数，
【考研数据结构知识点详解及整理——C语言描述】第一章算法和算法评价
qq_63492484的博客
05-21 391
时间复杂度和空间复杂度
双非二本找工作前的准备day28
m0_61724447的博客
05-20 949
每天复习代码随想录上的题目2-3道算法（时间充足可以继续）
【代码随想录算法训练营第37期 第二十一天 | LeetCode530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先】
最新发布
cattte的博客
05-28 192
【代码】【代码随想录算法训练营第37期 第二十一天 | LeetCode530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先】
dijkstra算法讲解
05-09
Dijkstra算法是一种用于图形搜索的算法，用于计算图形中的最短路径。它以起始顶点为中心向外层层扩展，直到扩展到终点为止。 Dijkstra算法的步骤如下： 1. 将起始节点标记为已访问，并设置到起始节点的距离为0。 2....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值