【数据结构-数组】数组的相关算法

已于 2023-08-02 20:54:18 修改
阅读量519 收藏 3
点赞数 1
分类专栏： # 数据结构与算法 文章标签： 数据结构 算法 排序算法
于 2022-10-30 21:17:56 首次发布
本文章为作者原创，未经许可禁止转载。
本文链接：https://blog.csdn.net/baidu_39514357/article/details/127605349
版权

文章目录

1 无序数组的排序——快速排序

1.1 升序排序

一趟排序的思路：

  • 选取区间 A 最左边的元素 x 作为基准值；
  • 从区间 A 的最右边开始，往左找，碰到第一个比 x 小的元素时停下，把下标记为 j；（基准数在最左边，必须从最右边开始扫描！）
  • 从区间 A 的最左边开始，往右找，碰到第一个比 x 大的元素时停下，把下标记为 i；
  • 交换 A[i] 和 A[j]；
  • 继续从 j 往左找，再从 i 往右找，重复上述过程，直到 i 和 j 碰面为止，将 A[i] 与第一个元素 x 交换；
  • 将区间 A 分为两段：[最左边, i-1]，[i+1, 最右边]（或[最左边, j-1]，[j+1, 最右边]），重复上述过程。
void QSort (int A[], int low, int high){
    if (low >= high)
        return;

    int i = low, j = high; // 左右指针分别指向区间两端
    int pivot; // 基准值
    
    将 A 数组中随机一个元素和 A[low] 交换; // 随机选取基准值
    pivot = A[low]; // 最左边作为基准值
    
    while (i < j){
        while ((i < j) && (A[j] >= pivot)) // 右指针从区间右端往左端移动
            j--;
        while ((i < j) && (A[i] <= pivot)) // 左指针从区间左端往右端移动
            i++;
        if (i < j)
            swap(A[i], A[j]); // 交换 A[i] 和 A[j]
    }
    
    swap(A[low], A[i]); // 将基准值放入最终位置
    QSort(A, low, i-1); // 递归处理左区间
    QSort(A, i+1, high);  // 递归处理右区间
}

1.2 降序排序

一趟排序的思路：

  • 选取区间 A 最左边的元素 x 作为基准值；
  • 从区间 A 的最右边开始，往左找，碰到第一个比 x 大的元素时停下，把下标记为 j；（基准数在最左边，必须从最右边开始扫描！）
  • 从区间 A 的最左边开始，往右找，碰到第一个比 x 小的元素时停下，把下标记为 i；
  • 交换 A[i] 和 A[j]；
  • 继续从 j 往左找，再从 i 往右找，重复上述过程，直到 i 和 j 碰面为止，将 A[i] 与第一个元素 x 交换；
  • 将区间 A 分为两段：[最左边, i-1]，[i+1, 最右边]（或[最左边, j-1]，[j+1, 最右边]），重复上述过程。
void QSort (int A[], int low, int high){
    if (low >= high)
        return;

    int i = low, j = high; // 左右指针分别指向区间两端
    int pivot; // 基准值
    
    将 A 数组中随机一个元素和 A[low] 交换; // 随机选取基准值
    pivot = A[low]; // 最左边作为基准值
    
    while (i < j){
        while ((i < j) && (A[j] >= pivot)) // 右指针从区间右端往左端移动
            j--;
        while ((i < j) && (A[i] <= pivot)) // 左指针从区间左端往右端移动
            i++;
        if (i < j)
            swap(A[i], A[j]); // 交换 A[i] 和 A[j]
    }
    
    swap(A[low], A[i]); // 将基准值放入最终位置
    QSort(A, low, i-1); // 递归处理左半区间
    QSort(A, i+1, high);  // 递归处理右半区间
}

2 有序数组的查找——折半查找（二分查找）

2.1 升序数组的查找

  • 左闭右闭写法（[low, high]，推荐）：
// A：数组，low 和 high：数组区间左端点及右端点下标/索引，x：数组元素
int Search(int A[], int low, int high, int x){
    int mid;
    while (low <= high){ // 左闭右闭
        mid = low + (high - low) / 2;
        if (A[mid] > x) // 若中间值大于 x，说明 x 在左半段
            high = mid - 1;
        else if (A[mid] < x) // 若中间值小于 x，说明 x 在右半段
            low = mid + 1;
        else // 若中间值就是 x
            return mid;
    }
    return -1; // 查找失败
}
  • 左闭右开写法（[low, high)，high 对应的数组元素搜索不到）：
// A：数组，low 和 high：数组区间左端点及右端点下标/索引，x：数组元素
int Search(int A[], int low, int high, int x){
    int mid;
    while (low < high){ // 左闭右开，high 对应的数组元素搜索不到
        mid = low + (high - low) / 2;
        if (A[mid] > x) // 若中间值大于 x，说明 x 在左半段
            high = mid; // high 对应的数组元素搜索不到，即 [low, mid)
        else if (A[mid] < x) // 若中间值小于 x，说明 x 在右半段
            low = mid + 1;
        else // 若中间值就是 x
            return mid;
    }
    return -1; // 查找失败
}

2.2 降序数组的查找

  • 左闭右闭写法（[low, high]，推荐）：
// A：数组，low 和 high：数组区间左端点及右端点下标/索引，x：数组元素
int Search(int A[], int low, int high, int x){
    int mid;
    while (low <= high){ // 左闭右闭
        mid = low + (high - low) / 2;
        if (A[mid] < x) // 若中间值小于 x，说明 x 在左半段
            high = mid - 1;
        else if (A[mid] > x) // 若中间值大于 x，说明 x 在右半段
            low = mid + 1;
        else // 若中间值就是 x
            return mid;
    }
    return -1; // 查找失败
}
  • 左闭右开写法（[low, high)，high 对应的数组元素搜索不到）：
// A：数组，low 和 high：数组区间左端点及右端点下标/索引，x：数组元素
int Search(int A[], int low, int high, int x){
    int mid;
    while (low < high){ // 左闭右开，high 对应的数组元素搜索不到
        mid = low + (high - low) / 2;
        if (A[mid] < x) // 若中间值小于 x，说明 x 在左半段
            high = mid; // high 对应的数组元素搜索不到，即 [low, mid)
        else if (A[mid] > x) // 若中间值大于 x，说明 x 在右半段
            low = mid + 1;
        else // 若中间值就是 x
            return mid;
    }
    return -1; // 查找失败
}

3 有序数组的合并——归并思想

3.1 归并两个升序数组

int C[n+m]; // 全局新数组

// 数组 A 及其长度 n，数组 B 及其长度 m
void UpMerge (int A[], int n, int B[], int m){
    int i = j = 0; // i，j 指针指向数组 A 和 B
    int k = 0;     // k 指针指向数组 C
    
    while ((i < n) && (j < m)){  // 当有一个数组遍历完时，退出循环
        if (A[i] < B[j]){ // 较小者先进入新数组
            C[k] = A[i];
            i++;
        }
        else{
            C[k] = B[j];
            j++;
        }
        k++;
    }
    
    // 剩余元素直接进入新数组
    for (; i < n; i++, k++)
        C[k] = A[i];
    for (; j < m; j++, k++)
        C[k] = B[j];
}

3.2 归并两个降序数组

int C[n+m]; // 全局新数组

// 数组 A 及其长度 n，数组 B 及其长度 m
void DownMerge (int A[], int n, int B[], int m){
    int i = j = 0; // i，j 指针指向数组 A 和 B
    int k = 0;     // k 指针指向数组 C
    
    while ((i < n) && (j < m)){  // 当有一个数组遍历完时，退出循环
        if (A[i] > B[j]){ // 较大者先进入新数组
            C[k] = A[i];
            i++;
        }
        else{
            C[k] = B[j];
            j++;
        }
        k++;
    }
    
    // 剩余元素直接进入新数组
    for (; i < n; i++, k++)
        C[k] = A[i];
    for (; j < m; j++, k++)
        C[k] = B[j];
}

3.3 升序和降序归并为升序

int C[n+m]; // 全局新数组

// 升序数组 A 及其长度 n，降序数组 B 及其长度 m
void UpMerge (int A[], int n, int B[], int m){
    int i = 0; // i 指针指向数组 A
    int j = m; // j 指针指向数组 B
    int k = 0; // k 指针指向数组 C
    
    while ((i < n) && (j > 0)){  // 当有一个数组遍历完时，退出循环
        if (A[i] > B[j]){ // 较小者先进入新数组
            C[k] = A[i];
            i++;
        }
        else{
            C[k] = B[j];
            j--;
        }
        k++;
    }
    
    // 剩余元素直接进入新数组
    for (; i < n; i++, k++)
        C[k] = A[i];
    for (; j = 0; j--, k++)
        C[k] = B[j];
}

3.4 升序和降序归并为降序

int C[n+m]; // 全局新数组

// 升序数组 A 及其长度 n，降序数组 B 及其长度 m
void DownMerge (int A[], int n, int B[], int m){
    int i = n; // i 指针指向数组 A
    int j = 0; // j 指针指向数组 B
    int k = 0; // k 指针指向数组 C
    
    while ((i > 0) && (j < m)){  // 当有一个数组遍历完时，退出循环
        if (A[i] > B[j]){ // 较大者先进入新数组
            C[k] = A[i];
            i--;
        }
        else{
            C[k] = B[j];
            j++;
        }
        k++;
    }
    
    // 剩余元素直接进入新数组
    for (; i = 0; i--, k++)
        C[k] = A[i];
    for (; j < m; j++, k++)
        C[k] = B[j];
}

4 数组元素的删除——快慢指针

  • 快指针：正常遍历数组元素
  • 慢指针：遇到多少个满足条件的元素就滞后于快指针多少个位置，同时能记录删除后需要保存的元素个数

4.1 删除特定元素

4.1.1 无序表中删除所有值为 x 的元素

从线性表中删除所有其值为 x 的元素，要求时间复杂度为 O(n)，空间复杂度为 O(1)。

  • 解法一（推荐）：
void Delete_x (int A[], int x){
    int i; // 快指针，正常遍历数组元素
    int j; // 慢指针，遇到多少个值为 x 的元素就滞后于快指针多少个位置，即需要保存的元素个数
    
    for (i = 0, j = 0; i < length; i++){ // 快指针，正常遍历数组元素
        if (A[i] != x){     // 如果不是值为 x 的元素
            A[j] = A[i];    // 当前元素往前移 i-j 个位置，即移到下标为 j 的位置
            j++;            // 慢指针 + 1
        }
        // 如果是值为 x 的元素，则慢指针 j 不加 1，这样就和快指针 i 多滞后了一个位置
        // 此时 j 指向值为 x 的元素
    }
    
    length = j;
}
  • 解法二：
void Delete_x (int A[], int x){
    int i; // 快指针，正常遍历数组元素
    int j; // 慢指针，遇到多少个值不为 x 的元素就滞后于快指针多少个位置
    
    for (i = 0, j = 0; i < length; i++){
        if (A[i] == x)  // 如果是值为 x 的元素
            j++;        // 慢指针 + 1
        else            // 如果不是值为 x 的元素
            A[i-j] = A[i];  // 当前元素往前移 j 个位置，即移到下标为 i-j 的位置
    }
    
    length = length - j;
}
4.1.2 有序表中删除所有值为 x 的元素

从有序表中删除所有其值为 x 的元素。

void Delete_x (int A[], int x){
    int i = 0; // 头指针
    int j = length - 1; // 尾指针
    
    while ((A[i] != x) && (i < length)) // 从表头开始往右找第一个值等于 x 的元素
        i++;
    while ((A[j] != x) && (j >= 0)) // 从表尾开始往左找第一个值小于等于 t 的元素
        j--;
    
    int d = j - i + 1;
    for (; j < length; j++) // 将元素前移
        L.data[j - d] = L.data[j];
        
    length = length - d;
}

4.2 删除值为 s 到 t 之间的所有元素

4.2.1 无序表中删除值为 s 到 t 之间的所有元素

从顺序表中删除其值为 s 到 t 之间的所有元素。

  • 解法一（推荐）：
void Delete_s_t (int A[], int s, int t){
    int i; // 快指针，正常遍历数组元素
    int j; // 慢指针，遇到多少个值为 s 到 t 之间的元素就滞后于快指针多少个位置，即需要保存的元素个数
    
    for (i = 0, j = 0; i < length; i++){    // 快指针，正常遍历数组元素
        if ((A[i] < s) || (A[i] > t)){      // 如果不是 s 到 t 之间的元素
            A[j] = A[i];    // 当前元素往前移 i-j 个位置，即移到下标为 j 的位置
            j++;            // 慢指针 + 1
        }
        // 如果是 s 到 t 之间的元素，则慢指针 j 不加 1，这样就和快指针 i 多滞后了一个位置
        // 此时 j 指向值为 x 的元素
    }
    
    length = j;
}
  • 解法二：
void Delete_x (int A[], int x){
    int i; // 快指针，正常遍历数组元素
    int j; // 慢指针，遇到多少个值不为 s 到 t 之间的元素就滞后于快指针多少个位置
    
    for (i = 0, j = 0; i < length; i++){
        if ((s <= A[i]) && (A[i] <= t))  // 如果是值为 s 到 t 之间的元素
            j++;        // 慢指针 + 1
        else            // 如果不是值为 s 到 t 之间的元素
            A[i-j] = A[i];  // 当前元素往前移 j 个位置，即移到下标为 i-j 的位置
    }
    
    length = length - j;
}
4.2.2 有序表中删除值为 s 到 t 之间的所有元素

从有序表中删除其值为 s 到 t 之间的所有元素。

void Delete_s_t (int A[], int s, int t){
    int i = 0; // 头指针
    int j = length - 1; // 尾指针
    
    while ((A[i] < s) && (i < length)) // 从表头开始往右找第一个值大于等于 s 的元素
        i++;
    while ((A[j] > t) && (j >= 0)) // 从表尾开始往左找第一个值小于等于 t 的元素
        j--;
    
    int d = j - i + 1;
    for (; j < length; j++) // 将元素前移
        L.data[j - d] = L.data[j];
        
    length = length - d;
}

4.3 删除重复元素

4.3.1 有序表中删除所有重复的元素

从有序表中删除所有其值重复的元素，使表中所有元素的值均不相同。

  • 解法一（推荐）：
void Delete_Same (int A[]){
    int i; // 快指针，正常遍历数组元素，初始指向第 1 个元素
    int j; // 慢指针，遇到多少个重复元素就滞后于快指针多少个位置，即需要保存的元素个数，初始指向第 0 个元素
    
    for (i = 1, j = 0; i < length; i++){ // 快指针，正常遍历数组元素
        if (A[i] != A[j]){  // 如果当前元素和下标为 j 的元素不相等
            j++;            // 慢指针 + 1
            A[j] = A[i];    // 当前元素往前移 i-j 个位置，即移到下标为 j 的位置
        }
        // 如果当前元素和下标为 j 的元素相等，则慢指针 j 不加 1，这样就和快指针 i 多滞后了一个位置
        // 此时 j 指向重复元素组的第一个元素
    }
    
    length = j + 1;
}
  • 解法二：
void Delete_Same (int A[]){
    int prev = A[0]; // 记录前一个元素，初始值为 A[0]
    int i; // 快指针，正常遍历数组元素
    int j; // 慢指针，遇到多少个重复元素就滞后于快指针多少个位置，即需要保存的元素个数
    
    for (i = 1, j = 1; i < length; i++){ // 快指针，正常遍历数组元素
        if (A[i] != prev){  // 如果当前元素和前一个元素不重复
            prev = A[i];    // 更新记录前一个元素
            A[j] = A[i];    // 当前元素往前移 j 个位置
            j++;            // 慢指针 + 1
        }
        // 如果当前元素和前一个元素重复，则慢指针 j 不加 1，这样就和快指针 i 多滞后了一个位置
        // 此时 j 指向重复元素组的第一个元素
    }
    
    length = j;
}
4.3.2 无序表中删除所有重复的元素

从顺序表中删除所有其值重复的元素，使表中所有元素的值均不相同。

  • 解法：若要使时间复杂度为 O(n)，则需使用散列表。

（略）

5 数组的相关算法杂例

5.1 数组逆置

// 数组 A，区间左端点下标 low，区间右端点下标 high
void Reverse (int A[], int low, int high){
    for (int i = low; i <= low + (high - low) / 2; i++)
        swap(A[i], A[high - i]); // 交换头尾元素
}

5.2 求数组的最大和最小元素

#define INT_MAX 0x7FFFFFFF // int 型最大值

// 求最小元素
// 数组 A，区间左端点下标 low，区间右端点下标 high
int Min (int A[], int low, int high){
    int A_Min = INT_MAX;
    for (int i = low; i <= high; i++){
        if (A[i] < D_Min)
            A_Min = A[i];
    }
    return A_Min;
}

#define INT_MIN 0x80000000 // int 型最小值

// 求最大元素
// 数组 A，区间左端点下标 low，区间右端点下标 high
int Max (int A[], int low, int high){
    int A_Max = INT_MIN;
    for (int i = low; i <= high; i++){
        if (A[i] > D_Max)
            A_Max = A[i];
    }
    return A_Max;
}

5.3 求多数元素——摩尔投票法

给定一个大小为 n 的整数数组，找出其中所有出现超过 ⌊ n/2 ⌋ 次的元素。

（略）

Mount256
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法之数组
m0_50046535的博客
04-05 53
参考自《代码随想录》 数组是存放在连续内存空间的相同类型的数据的结合。 数组可以方便的通过下标索引的方式获取到下标对应的数据。 注意 数组下标都是从0开始，内存空间地址是连续的。 因此在删除或增加元素的时候，就要移动其他元素的位置。 二分查找： 前提条件：有序数组、无重复元素，可以考虑二分查找。 明确对区间的定义，写二分法，区间定义一般分为两种，左闭右闭[ , ]，左闭右开[ ，)。 二分法两种写法： 1.左闭右闭，定义目标在一个左闭右闭的区间里， 应为目标在[left，right]；所
【数据结构与算法】数组与链表
dadongwudi的博客
08-03 466
数组的定义和特性 数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。 线性表（Linear List）：数组、链表、队列、栈 非线性表：树 图 连续的内存空间和相同类型的数据 性能 低效“插入”和“删除” 警惕 数组越界 数组和链表的区别 “链表适合插入、删除，时间复杂度 O(1)；数组适合查找，数组支持随机访问，根据下标随机访问的时间复杂度为 O(1)”。 （数组是适合查找操作，但是查找的时间复杂度并不为 O(1)。即便是排好序的数组，你
数组的常见算法
weixin_62914558的博客
07-28 770
数组的创建与元素的赋值；数组的赋值与复制；数组的反转；数组中指定元素的查找：搜索、检索；数组的排序算法（冒泡算法）
数组的五大简单算法
qq_56870066的博客
09-19 365
数组几大算法1.倒置算法2.查找算法2.1.顺序查找2.2.折半查找3.插入算法4. 删除算法5. 排序算法5.1. 冒泡排序5.2. 插入排序5.3. 选择排序5.4. 快速排序 1.倒置算法 //数组倒置 # include <stdio.h> int main(void) { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int arr2[10] = { 0 };//用来存放倒置之后的内容 int i, j; for (i = 0, j = 9;
简单的冒泡排序
不曾留得桃花影
01-10 210
冒泡排序 介绍： 冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元 素，如果他们的顺序错误就把他们交换过来。 排序思想： 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步 做完后，最后的元素会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有...
数组常见算法汇总
MrDAW的博客
07-22 1549
数组常见算法汇总 1、寻找数组中的最大值 | 最小值 ` public class max_min { public static void main(String[] args) { int[] nums = {10,20,30,40,33,22,11,8}; //1.创建一个变量，用于存储遍历数组发现的最大值 int n = nums[0]; for (int i = 1; i < nums.length; i++) {
数组中涉及到的常见算法
xiaotai1234的博客
08-09 1128
数组中涉及到的常见算法 1.数组元素的赋值(杨辉三角、回形数等) 面试题目：创建一个长度为6的int型数组，要求取值为1-30，同时元素值各不相同 class ArrayExer { public static void main(String[] args) { //方式一： // int[] arr = new int[6]; // for (int i = 0; i < arr.length; i++) {// [0,1) [0,30) [1,31) // arr[i] = (in
数据结构-数组.zip
09-21
在这个"数据结构-数组.zip"压缩包中，包含三个核心知识点：多项式操作、稀疏矩阵处理以及字符串匹配的KMP算法。 首先，我们来看多项式。在数学中，多项式是由常数、变量和它们的乘积组成的表达式。在编程中，我们...
数据结构-数组与广义表.ppt
07-11
数据结构是计算机科学中至关重要的概念，用于组织和...理解这些数据结构的基本概念和操作是学习计算机科学，尤其是算法和数据结构的基础。在实际编程中，正确选择和使用这些数据结构可以显著提高程序的效率和可维护性。
数据结构--数组、单链表和双链表介绍以及双向链表 数组和链表.pdf
04-18
数据结构--数组、单链表和双链表介绍以及双向链表 数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。数组、链表是两种常见的数据结构，下面将对它们进行介绍。 一、数组 数组是数据结构中的一...
第七章-数组数据结构与数组的概念-影响程序设计的因素优秀文档.ppt
12-01
"数组数据结构与数组的概念" 本文档主要介绍了数组数据结构与数组的概念，并对其进行了详细的...数组数据结构与数组的概念是程序设计中非常重要的概念，选择合适的数据类型可以降低算法的复杂程度，提高程序的效率。
第七章-数组-数据结构与数组的概念-影响程序设计的因素优秀文档.ppt
12-01
"数据结构与数组的概念" 本章节主要讲解了数据结构与数组的概念，强调了数据结构在程序设计中的重要性。数据结构是指选择合适的数据类型来存放要处理的数据，而数组是指一组具有同样类型的数据的集合。选择合适的...
【算法与数据结构 07】数组 —— 数组的基本操作( 增删查与时间复杂度的关系！)
不积跬步，无以至千里！
09-02 2392
最简明的《数据结构与算法》教程，不谈废话，专为小白设计！
03.数组及其经典算法
松松的博客
08-08 251
数组： 数组是相同类型数据的有序集合。数组描述的是相同类型的若干数据，按照一定的先后次序排列组合而成。 基本特点： 不能同时静态初始化又动态初始化，即: int[] arr = new int[2]{1,2};会报错 长度确定，一把被创建，大小就是不可改变的。 数组内元素必须是相同类型 数组类型可以是任何数据类型，包括基本类型和引用类型 数组变量属于引用类型，数组可以看成是对象，数组中的每个...
数组常见相关问题及算法
江韵的博客
10-24 1122
从数组的使用到数组相关排序算法 数组异常原因
算法数据结构基础——数组
白话机器学习
06-02 172
数组（Array）：一种线性表数据结构。它使用一组连续的内存空间，来存储一组具有相同类型的数据。简单来说，「数组」是实现线性表的顺序结构存储的基础。以整数数组为例，数组的存储方式如下图所示。如上图所示，数组中的每一个数据元素都有自己的下标索引，下标索引从0开始，到数组元素个数 - 1结束。数组中的每一个「下标索引」，都有一个与之相对应的「数据元素」。从上图还可以看出，数组在计算机中的表示，就是一片连续的存储单元。
数组常见算法
weixin_64975807的博客
03-05 2089
数组排序、数组有序和无序查找和数组旋转、乱序算法
【Java--数据结构】二叉树
最新发布
2301_80898480的博客
07-16 1055
如有错误，欢迎指出~
矩阵转置算法与数据结构-数组和广义表
"本资源主要讨论了如何求矩阵的转置以及数组和广义表的相关概念，包括数组的存储结构、稀疏矩阵的压缩存储、广义表的定义和操作等，特别强调了矩阵转置的算法和广义表的递归算法。" 在计算机科学中，矩阵是一个重要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值