（Data Structure）数据结构第五章 数组和广义表

于 2023-04-24 19:47:14 发布
阅读量170 收藏
点赞数
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73120357/article/details/130337448
版权

第五章 数组和广义表

5.1 数组的定义

  • 在计算机科学中，数组数据结构（英语：array data structure），简称数组（英语：Array），是由相同类型的元素（element）的集合所组成的数据结构，分配一块连续的内存来存储。利用元素的索引（index）可以计算出该元素对应的存储地址

数组与线性表

  • 相同之处：
    它们都是若干个相同数据类型的数据元素a0,a1,a2,…，an-1，构成的有限序列
  • 不同之处：
    (1)数组要求其元素占用一块地址连续的内存单元空间，而线性表无此要求
    (2)线性表的元素是逻辑意义上不可再分的元素，而数组中的每个元素还可以是一个数组
    (3)数组的操作主要是向某个下标的数组元素中存放数据和取某个下标的数组元素，这与线性表的插入和删除操作不同

在这里插入图片描述

  • 结论：线性表结构是数组结构的一个特例，而数组结构又是线性表结构的扩展

5.2 数组的顺序表示和实现

  • 数组结构也可以使用两种存储结构，即顺序存储结构和链式存储结构

  • 一维数组（n个元素）中任一元素ai的内存单元地址

在这里插入图片描述

  • 一个m行n列的二维数组

在这里插入图片描述
注：C语言中数组元素采用行主序的存放方法，即行优先顺序

在这里插入图片描述

5.3 特殊矩阵和稀疏矩阵的存储

  • 在计算机中，矩阵是一种常见的数据结构，用于表示二维的数值数组。计算机中的矩阵通常通过二维数组或列表的形式来表示，其中每个元素都可以通过其在矩阵中的行和列的索引进行访问

在这里插入图片描述

  • 对称矩阵：对称矩阵是一种特殊的方阵，其主对角线上的元素对称地分布在矩阵的上下三角中。即，对称矩阵A的第i行第j列的元素等于其第j行第i列的元素，即A[i][j] = A[j][i]，对称矩阵关于其主对角线是对称的
    在这里插入图片描述
void compressSymmetricMatrix(int matrix[MAX_SIZE][MAX_SIZE], int n, int compressedArray[])
{
    int k = 0;
    for (int i = 0; i < n; i++)
    {
        compressedArray[k++] = matrix[i][i]; // 存储对角线上的元素
        for (int j = i + 1; j < n; j++)
        {
            compressedArray[k++] = matrix[i][j]; // 存储上三角或下三角的元素
        }
    }
}
  • 三角矩阵：三角矩阵是方形矩阵的一种，因其非零系数的排列呈三角形状而得名。三角矩阵分上三角矩阵和下三角矩阵两种。上三角矩阵的对角线左下方的系数全部为零，下三角矩阵的对角线右上方的系数全部为零。
    在这里插入图片描述
void compressTriangularMatrix(int matrix[MAX_SIZE][MAX_SIZE], int n, int compressedArray[])
{
    int k = 0;
    for (int i = 0; i < n; i++)
    {
        compressedArray[k++] = matrix[i][i]; // 存储对角线元素
        for (int j = i + 1; j < n; j++)
        {
            compressedArray[k++] = matrix[i][j]; // 存储上三角元素
        }
    }
}
  • 对角矩阵：对角矩阵是一个主对角线之外的元素皆为0的矩阵，对角线上的元素可以为0或其他值
    在这里插入图片描述
void compressDiagonalMatrix(int matrix[MAX_SIZE][MAX_SIZE], int n, int compressedArray[])
{
    for (int i = 0; i < n; i++)
    {
        compressedArray[i] = matrix[i][i]; // 存储对角线元素
    }
}
  • 稀疏矩阵：稀疏矩阵是指在数值分析中，其元素大部分为零的矩阵

定义

// 三元组
typedef struct {
    int i, j;
    int e;
} Triple;

// 稀疏矩阵
typedef struct {
    Triple data[MAXSIZE + 1];
    int mu, nu, tu;
} Matrix;

打印

// 打印稀疏矩阵
void printMatrix(Matrix M) {
    int i, j, k = 1;
    for (i = 1; i <= M.mu; i++) {
        for (j = 1; j <= M.nu; j++) {
            // 判断是否为非零元素
            if (i == M.data[k].i && j == M.data[k].j) {
                printf("%d\t", M.data[k].e);
                k++;
            } else {
                printf("0\t");
            }
        }
        printf("\n");
    }
}

转置
在这里插入图片描述

两种实现算法：
1.按列 col(1≤col≤M.nu)扫描三元表M.data，找出所有列号等于col的那些三元组，将它们的行号和列号互后依次放入T.data中 （跳着找，顺着存）
2. 先计算出M中每列第一个非零元素在T的三元表中的存储位置（用pot[]数组保存），然后按行扫描M的三元表的元素（顺着找，跳着存）

// 转置稀疏矩阵
void transionMatrix(Matrix M, Matrix *T) {
    T->mu = M.nu;
    T->nu = M.mu;
    T->tu = M.tu;
    if (T->tu) {
        int q = 1;
        // 遍历每一列
        for (int col = 1; col <= M.nu; col++) {
            for (int p = 1; p <= M.tu; p++) {
                // 判断是否为非零元素
                if (M.data[p].j == col) {
                    T->data[q].i = M.data[p].j;
                    T->data[q].j = M.data[p].i;
                    T->data[q].e = M.data[p].e;
                    q++;
                }
            }
        }
    }
}

// 转置稀疏矩阵
void transionMatrix2(Matrix M, Matrix *T) {
    T->mu = M.nu;
    T->nu = M.mu;
    T->tu = M.tu;
    if (T->tu) {
        int num[M.nu], cpot[M.nu];
        int col, p, q;

        // 初始化
        for (col = 1; col <= M.nu; col++) {
            num[col] = 0;
        }
        // 计算每一列的非零元素个数
        for (p = 1; p <= M.tu; p++) {
            num[M.data[p].j]++;
        }
        cpot[1] = 1;
        // 计算每一列第一个非零元素在三元组表中的位置
        for (col = 2; col <= M.nu; col++) {
            cpot[col] = cpot[col - 1] + num[col - 1];
        }

        // 转置
        for (p = 1; p <= M.tu; p++) {
            col = M.data[p].j;
            q = cpot[col];
            T->data[q].i = M.data[p].j;
            T->data[q].j = M.data[p].i;
            T->data[q].e = M.data[p].e;
            cpot[col]++;
        }
    }
}

5.4 广义表

  • 广义表是一种非线性的数据结构，它可以包含原子和子表。如果广义表的每个元素都是原子，它就变成了线性表，它由n ( ≥0 )个表元素组成的有限序列，记作LS = (a0, a1, a2, …, an-1) LS是表名，ai是表元素，它可以是表 (称为子表)，可以是数据。广义表的元素可以是子表，而子表的元素还可以是子表
    在这里插入图片描述
  • 由于广义表(a1,a2,a3,…an)中的数据元素可以具有不同的结构，（或是原子，或是广义表），因
    此，难以用顺序存储结构表示，通常采用链式存储结构，每个数据元素可用一个结点表示
    两种链式存储方法
    1：头尾链表表示法
    2：扩展线性链表表示法

定义

typedef struct GLNode {
    int tag;
    union {
        ElemType data;
        struct {
            struct GLNode *hp, *tp;
        } ptr;
    } u;
} * GList;

创建

void CreateGList(GList *L) {
    char c;
    scanf("%c", &c);
    if (c == '#') {
        *L = NULL;
    } else if (c == '(') {
        *L = (GList) malloc(sizeof(struct GLNode));
        (*L)->tag = 1;
        CreateGList(&((*L)->u.ptr.hp));
        CreateGList(&((*L)->u.ptr.tp));
    } else {
        *L = (GList) malloc(sizeof(struct GLNode));
        (*L)->tag = 0;
        (*L)->u.data = c;
        CreateGList(&((*L)->u.ptr.tp));
    }
}

完整代码

1.对称矩阵

#include <stdio.h>

#define MAX_SIZE 100

void compressSymmetricMatrix(int matrix[MAX_SIZE][MAX_SIZE], int n, int compressedArray[])
{
    int k = 0;
    for (int i = 0; i < n; i++)
    {
        compressedArray[k++] = matrix[i][i]; // 存储对角线上的元素
        for (int j = i + 1; j < n; j++)
        {
            compressedArray[k++] = matrix[i][j]; // 存储上三角或下三角的元素
        }
    }
}

void decompressSymmetricMatrix(int compressedArray[], int n, int matrix[MAX_SIZE][MAX_SIZE])
{
    int k = 0;
    for (int i = 0; i < n; i++)
    {
        matrix[i][i] = compressedArray[k++]; // 恢复对角线上的元素
        for (int j = i + 1; j < n; j++)
        {
            matrix[i][j] = compressedArray[k];   // 恢复上三角或下三角的元素
            matrix[j][i] = compressedArray[k++]; // 对称性质，填充对应位置的元素
        }
    }
}

int main()
{
    int n;                                              // 矩阵的大小
    int matrix[MAX_SIZE][MAX_SIZE];                     // 原始对称矩阵
    int compressedArray[MAX_SIZE * (MAX_SIZE + 1) / 2]; // 压缩后的数组

    printf("请输入对称矩阵的大小：");
    scanf("%d", &n);

    printf("请输入对称矩阵的元素：\n");
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            scanf("%d", &matrix[i][j]);
        }
    }

    compressSymmetricMatrix(matrix, n, compressedArray);

    printf("压缩后的数组为：\n");
    for (int i = 0; i < n * (n + 1) / 2; i++)
    {
        printf("%d ", compressedArray[i]);
    }
    printf("\n");

    int decompressedMatrix[MAX_SIZE][MAX_SIZE]; // 解压缩后的矩阵
    decompressSymmetricMatrix(compressedArray, n, decompressedMatrix);

    printf("解压缩后的矩阵为：\n");
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            printf("%d ", decompressedMatrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

2.三角矩阵

#include <stdio.h>

#define MAX_SIZE 100

void compressTriangularMatrix(int matrix[MAX_SIZE][MAX_SIZE], int n, int compressedArray[])
{
    int k = 0;
    for (int i = 0; i < n; i++)
    {
        compressedArray[k++] = matrix[i][i]; // 存储对角线元素
        for (int j = i + 1; j < n; j++)
        {
            compressedArray[k++] = matrix[i][j]; // 存储上三角元素
        }
    }
}

void decompressTriangularMatrix(int compressedArray[], int n, int matrix[MAX_SIZE][MAX_SIZE])
{
    int k = 0;
    for (int i = 0; i < n; i++)
    {
        matrix[i][i] = compressedArray[k++]; // 恢复对角线元素
        for (int j = i + 1; j < n; j++)
        {
            matrix[i][j] = compressedArray[k++]; // 恢复上三角元素
            matrix[j][i] = 0;                    // 填充对称位置的元素为零
        }
    }
}

int main()
{
    int n;                                              // 矩阵的大小
    int matrix[MAX_SIZE][MAX_SIZE];                     // 原始矩阵
    int compressedArray[MAX_SIZE * (MAX_SIZE + 1) / 2]; // 压缩后的数组

    printf("请输入三角矩阵的大小：");
    scanf("%d", &n);

    printf("请输入三角矩阵的元素：\n");
    for (int i = 0; i < n; i++)
    {
        for (int j = i; j < n; j++)
        {
            scanf("%d", &matrix[i][j]);
        }
    }

    compressTriangularMatrix(matrix, n, compressedArray);

    printf("压缩后的数组为：\n");
    for (int i = 0; i < n * (n + 1) / 2; i++)
    {
        printf("%d ", compressedArray[i]);
    }
    printf("\n");

    int decompressedMatrix[MAX_SIZE][MAX_SIZE]; // 解压缩后的矩阵
    decompressTriangularMatrix(compressedArray, n, decompressedMatrix);

    printf("解压缩后的矩阵为：\n");
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            printf("%d ", decompressedMatrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

3.对角矩阵

#include <stdio.h>

#define MAX_SIZE 100

void compressDiagonalMatrix(int matrix[MAX_SIZE][MAX_SIZE], int n, int compressedArray[])
{
    for (int i = 0; i < n; i++)
    {
        compressedArray[i] = matrix[i][i]; // 存储对角线元素
    }
}

void decompressDiagonalMatrix(int compressedArray[], int n, int matrix[MAX_SIZE][MAX_SIZE])
{
    for (int i = 0; i < n; i++)
    {
        matrix[i][i] = compressedArray[i]; // 恢复对角线元素
    }
}

int main()
{
    int n;                          // 矩阵的大小
    int matrix[MAX_SIZE][MAX_SIZE]; // 原始矩阵
    int compressedArray[MAX_SIZE];  // 压缩后的数组

    printf("请输入对角矩阵的大小：");
    scanf("%d", &n);

    printf("请输入对角矩阵的元素：\n");
    for (int i = 0; i < n; i++)
    {
        scanf("%d", &matrix[i][i]);
    }

    compressDiagonalMatrix(matrix, n, compressedArray);

    printf("压缩后的数组为：\n");
    for (int i = 0; i < n; i++)
    {
        printf("%d ", compressedArray[i]);
    }
    printf("\n");

    int decompressedMatrix[MAX_SIZE][MAX_SIZE]; // 解压缩后的矩阵
    decompressDiagonalMatrix(compressedArray, n, decompressedMatrix);

    printf("解压缩后的矩阵为：\n");
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (i == j)
            {
                printf("%d ", decompressedMatrix[i][j]);
            }
            else
            {
                printf("0 ");
            }
        }
        printf("\n");
    }

    return 0;
}

4.广义表

#include <stdio.h>
#include <stdlib.h>

#define ElemType int

typedef struct GLNode {
    int tag; // 标志域，0表示原子，1表示子表
    union {
        ElemType data; // 原子结点的值域
        struct {
            struct GLNode *hp, *tp; // 指向表头和表尾的指针域
        } ptr; // 子表结点的指针域
    } u;
} * GList;

void CreateGList(GList *L) { // 创建广义表
    char c;
    scanf("%c", &c);
    if (c == '#') { // 空表
        *L = NULL;
    } else if (c == '(') { // 子表
        *L = (GList) malloc(sizeof(struct GLNode));
        (*L)->tag = 1;
        CreateGList(&((*L)->u.ptr.hp)); // 递归创建子表的表头
        CreateGList(&((*L)->u.ptr.tp)); // 递归创建子表的表尾
    } else { // 原子
        *L = (GList) malloc(sizeof(struct GLNode));
        (*L)->tag = 0;
        (*L)->u.data = c;
        CreateGList(&((*L)->u.ptr.tp)); // 递归创建原子后面的元素
    }
}

void PrintGList(GList L) { // 打印广义表
    if (L == NULL) { // 空表
        printf("#");
    } else if (L->tag == 0) { // 原子结点
        printf("%c", L->u.data);
        PrintGList(L->u.ptr.tp); // 递归打印原子后面的元素
    } else { // 子表结点
        printf("(");
        PrintGList(L->u.ptr.hp); // 递归打印子表的表头
        printf(",");
        PrintGList(L->u.ptr.tp); // 递归打印子表的表尾
        printf(")");
    }
}

int main() {
    GList L;
    CreateGList(&L);
    PrintGList(L);
    return 0;
}
汽水汽水
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构总结】第四章：串、数组和广义表（线性结构）
weixin_43697439的博客
12-06 588
第四章：串、数组和广义表（线性结构） 提示：本文主要是以思维导图的形式概括数据结构第一章的精华内容，基本不会用到文字性的内容，目的是为了给大家梳理每个重要的知识点的相关概念，方便大家在复盘的时候快速阅读和浏览，加快记忆速度，提高复习效率！ 一、思维导图 二、总结 （1）记忆时按照每个结点展开的顺序，从上到下，从左到右记忆，效果更好； （2）注意文中的黄字内容，要加深对相关概念的理解和记忆； （3）掌握计算地址位置的方法，区分按行展开和按列展开的计算过程。 ...
通过代码快速上手C语言数据结构-数组和广义表
aiqq136的博客
05-10 479
5.1稀疏矩阵转置经典 5.2稀疏矩阵“列序”递增转置 5.3稀疏矩阵“”—次定位快速转置” 5.4建立稀疏矩阵的十字链表 5.5求广义表的表头 5.6求广义表的表尾 5.7求广义表的长度 5.8求广义表的深度 5.9-1统计广义表中原子数目方法 5.9-2统计广义表中原子数目方法 5.10复制广义表 ...
C++数据结构——数组与广义表
GeekZW的博客
06-29 2544
                                 C++数据结构——数组与广义表 参考博客： （1）理论：https://www.cnblogs.com/KennyRom/p/5971853.html （2）理论：https://www.cnblogs.com/zyrblog/p/6870097.html （3）题型：https://www.cnblogs.com/xing...
数据结构基础系列(5)：数组与广义表
10-07
数据结构课程是计算机类专业的专业基础课程，在IT人才培养中，起着重要的作用。课程按照大学计算机类专业课程大纲的要求，安排教学内容，满足需要系统学习数据结构的人。系列课程包含11个部分，本课为第5部分串，介绍数组的基本概念，特殊矩阵的压缩存储及基本运算的实现，以及广义表及其存储和相关的算法。
【图解数据结构】数组和广义表全面总结
知心宝贝的博客
12-10 8767
一、数组的定义 1.基本概念 数组：按照一定格式排列同属性的值，为相同数据类型元素的集合。常用的有一维数组A[5]、二维数组A[5][5]、多维数组等。 二维数组：通常把二维数组作为多维数组的代表，可以看出m个n维的线性表组成，如： 2.抽象数据类型 ADT Array {数据对象：D＝{aj1j2…jn | ji =0,...,bi-1, i=1,2,..,n, n(>0)称为数组的维数，bi是数组第i维的长度， ji是数组元素的第i维下标，aj1j2…jn∈El...
【精品课件】数据结构与算法 数据结构与C语言 data structure课程 第4章 串、数组和广义表（共66页）.ppt
11-05
数据结构与算法 数据结构与C语言 第4章 串、数组和广义表（共66页）.ppt 数据结构与算法 数据结构与C语言 第5章 树和二叉树（共95页）.ppt 数据结构与算法 数据结构与C语言 第6章 图（共126页）.ppt 数据结构与算法 ...
【精品课件】数据结构与算法 数据结构与C语言 data structure课程 全套PPT课件 共9个章节.rar
11-21
数据结构与算法 数据结构与C语言 data structure课程 第4章 串、数组和广义表（共66页）.ppt 数据结构与算法 数据结构与C语言 data structure课程 第5章 树和二叉树（共95页）.ppt 数据结构与算法 数据结构与C语言 ...
【精品课件】数据结构与算法 数据结构与C语言 data structure课程 第5章 树和二叉树（共95页）.ppt
11-05
数据结构与算法 数据结构与C语言 第4章 串、数组和广义表（共66页）.ppt 数据结构与算法 数据结构与C语言 第5章 树和二叉树（共95页）.ppt 数据结构与算法 数据结构与C语言 第6章 图（共126页）.ppt 数据结构与算法 ...
【精品课件】数据结构与算法 数据结构与C语言 data structure课程 第3章 栈和队列（共150页）.ppt
11-05
数据结构与算法 数据结构与C语言 第4章 串、数组和广义表（共66页）.ppt 数据结构与算法 数据结构与C语言 第5章 树和二叉树（共95页）.ppt 数据结构与算法 数据结构与C语言 第6章 图（共126页）.ppt 数据结构与算法 ...
【精品课件】数据结构与算法 数据结构与C语言 data structure课程 第8章 排序（共223页）.ppt
11-05
数据结构与算法 数据结构与C语言 第4章 串、数组和广义表（共66页）.ppt 数据结构与算法 数据结构与C语言 第5章 树和二叉树（共95页）.ppt 数据结构与算法 数据结构与C语言 第6章 图（共126页）.ppt 数据结构与算法 ...
数据结构（清华大学版）——数组和广义表
04-19
数据结构（清华大学版）——数组和广义表
数据结构中的数组和广义表,C语言
08-28
5.1 数组的基本概念 5.2 稀疏矩阵的三元组存储 5.3 稀疏矩阵的十字链表存储 5.4 广义表 5.5 迷宫问题 习题五
数据结构(数组和广义表)
09-13
数组、广义表、试题精选及答案，数据结构资源，很全
数据结构实验 数组和广义表
04-09
数组和广义表 一、实验名称：数组和广义表 二、实验目的： （1）熟悉C语言的上机环境，进一步掌握C语言的结构特点； （2）掌握线数组和广义表储存结构的定义及C语言实现； （3）掌握数组和广义表的各种基本操作； （4）学会利用数组和广义表的基本知识解决实际问题。 三、实验内容： 若矩阵中的某个元素是第i行中的最小值，同时又是第j列中的最大值，则称此元素为该矩阵中的一个马鞍点。假设以二维数组存储矩阵，试编写算法求出矩阵中的所有马鞍点。
数据结构入门----数组和广义表的概念及应用
qq1457346557的博客
07-08 2588
已经学过的线性表：数据元素都是非结构的原子类型。 数组和广义表的特点：一种特殊的线性表 ① 元素的值并非原子类型，可以再分解，表中元素也是一个线性表（即广义的线性表）。即数据元素本身也是一个数据结构。 ② 所有数据元素仍属同一数据类型。 数组的定义 数组： 由一组名字相同、下标不同的变量构成。 一维数组的特点：1个下标，ai 是ai+1的直接前驱 二维数组的特点：2个下标，每个元素ai,j受到两个关系（行关系和列关系）的约束： 一个m×n的二维数组可以看成是m行的一维数组，或者n列的一维
数据结构之数组与广义表
L*YUE的博客
01-27 5191
目录联系数组广义表 联系 数组和广义表可看作一种扩展的线性数据结构，其特殊性在于数据元素的构成上。从组成线性表的元素角度看，数组是由具有某种结构的数据元素构成，广义表则是由单个元素或子表构成的。数组和广义表是线性表的推广。 数组 1.数组的定义 从逻辑结构上，数组可以看成是对一般线性表的扩充。一维数组即为线性表，而二维数组可以定义为其数据元素为一维数组（线性表）的线性表。以此类推，N维数组是数据元...
数据结构之数组和广义表
热门推荐
AT弄潮儿
09-10 1万+
四、数组和广义表 数组的定义 数组是我们熟悉的数据类型，数组中各元素具有统一的类型，并且数组元素的下标一般具有固定的上界和下界，因此，数组的处理比其它复杂的结构更为简单。任何数组A都可以看作一个线性表。数组维数确定后，数据元素个数和元素之间的关系不再发生改变，适合顺序存储。数组的基本操作                                            
数据结构实践项目——数组和广义表
weixin_33692284的博客
10-18 313
本文针对 [数据结构基础系列网络课程(５)：数组和广义表] 1. 数组的基本概念与存储结构 2. 特殊矩阵的压缩存储 3. 稀疏矩阵的三元组表示 4. 稀疏矩阵的十字链表表示 5. 广义表 6. 广义表的存储结构及基本运算的实现 【项目1 - 猴子选大王（数组版）】 一群猴子，编号是1，2，3 …m，这群猴子（m个）按...
数据结构 数组和广义表
林夕
12-31 1807
文章目录1 数组的定义2 数组的顺序表示和实现2.1 二维数组2.2 n维数组2.3 随机存储结构3 矩阵的压缩存储3.1 特殊矩阵3.1.1 对称矩阵3.1.2 对角矩阵3.2 稀疏矩阵3.2.1 稀疏因子3.2.2 三元组顺序表3.2.3 行逻辑链接的顺序表3.2.4 十字链表4 广义表的定义4.1 形式表示4.2 原子和子表4.3 表头与表尾4.4 递归定义4.5 广义表特点5 广义表的存储...
数据结构：第5章数组和广义表A.ppt
06-12
Data structures play a crucial role in computer science, providing a way to store and organize data efficiently. In the 5th chapter of the presentation "Arrays and Generalized Lists A.ppt," we explore...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值