【C 数据结构】静态链表

最新推荐文章于 2024-04-27 22:24:35 发布
最新推荐文章于 2024-04-27 22:24:35 发布
阅读量1k 收藏 28
点赞数 21
分类专栏： 数据结构 文章标签： 数据结构 c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44431690/article/details/137601052
版权

文章目录

【 1. 基本原理 】

  • 静态链表，也是线性存储结构的一种，它兼顾了顺序表和链表的优点于一身，可以看做是顺序表和链表的升级版。
  • 使用静态链表存储数据， 数据全部存储在数组中（和顺序表一样），但存储位置是随机的，数据之间的逻辑关系通过一个整形变量（称为"游标"，和指针功能类似）维持（和链表类似）。通过 “数组+游标” 的方式存储具有线性关系数据的存储结构就是 静态链表。
  • 通常静态链表会将 第一个数据元素放到数组下标为 1 的位置（a[1]）中。

例如，使用静态链表存储 {1,2,3} 的过程如下：

  • 创建一个足够大的数组，假设大小为 6，如图所示：
    在这里插入图片描述
  • 在将数据存放到数组中时，给各个数据元素配备一个整形变量，此变量用于指明各个元素的直接后继元素所在数组中的位置下标，如图所示：
    在这里插入图片描述
  • 从 a[1] 存储的数据元素 1 开始，通过存储的游标变量 3，就可以在 a[3] 中找到元素 1 的直接后继元素 2；同样，通过元素 a[3] 存储的游标变量 5，可以在 a[5] 中找到元素 2 的直接后继元素 3，这样的循环过程直到某元素的游标变量为 0 截止（因为 a[0] 默认不存储数据元素）。

1.1 静态链表中的节点

  • 静态链表存储数据元素也需要自定义数据类型，至少需要包含以下 2 部分信息：
    • 数据域：用于存储数据元素的值；
    • 游标：其实就是数组下标，表示直接后继元素所在数组中的位置；
  • 因此，静态链表中节点的构成用 C 语言实现为：
typedef struct 
{
    int data;//数据域
    int cur;//游标
}component;

1.2 备用链表

  • 上图显示的静态链表还不够完整，静态链表中，除了数据本身通过游标组成的链表外，还需要有一条连接各个空闲位置的链表，称为 备用链表。备用链表的作用是 回收数组中未使用或之前使用过（目前未使用）的存储空间，留待后期使用。
    静态链表中设置备用链表的好处是可以清楚地知道数组中是否有空闲位置，以便数据链表添加新数据时使用。
  • 所以说，静态链表使用数组申请的物理空间中，存有两个链表：
    • 数据链表 用于 连接数据。表头通常位于数组下标为 1 的位置即 表头=a[1] 。
    • 备用链表 用于 连接数组中未使用的空间 。表头通常位于数组下标为 0 的位置即 表头=a[0] 。 备用链表最后1个节点的游标为 0 即指向表头，备用链表第1个节点存有值，则表明数据已存满 。

例如，使用静态链表存储 {1,2,3}，假设使用长度为 6 的数组 a，则存储状态可能如下图 所示：

  • 下图中，备用链表上连接的依次是 a[0]、a[2] 和 a[4]，而数据链表上连接的依次是 a[1]、a[3] 和 a[5]。
    在这里插入图片描述

【 2. 静态链表的创建 】

  • 假设使用静态链表（数组长度为 6）存储 1,2,3 ，则需经历以下几个阶段：
  1. 在数据链表未初始化之前，数组中所有位置都处于空闲状态，因此都应被链接在备用链表上，如下图所示：
    在这里插入图片描述
  • 当向静态链表中添加数据时，需提前从备用链表中摘除节点，以供新数据使用。
    备用链表 摘除节点最简单的方法是摘除 a[0] 的直接后继节点；同样，向备用链表中 添加空闲节点也是添加作为 a[0] 新的直接后继节点。因为 a[0] 是备用链表的第一个节点，我们知道它的位置，操作它的直接后继节点相对容易，无需遍历备用链表，耗费的时间复杂度为 O(1)。
  1. 向静态链表中添加元素 1 的过程如下图所示：
    在这里插入图片描述
  2. 在上图的基础上，添加元素 2 的过程如下图所示：
    在这里插入图片描述
  3. 在上图的基础上，继续添加元素 3 ，过程如下图所示。由此，静态链表就创建完成了。
    在这里插入图片描述

2.1 实例1 - 创建静态链表，指定值

#include <stdio.h>
#define maxSize 6

// 静态链表结构体
typedef struct
{
    int data; // 数据
    int cur;  // 游标，指向下一个存有数据的节点
}component;

// 创建备用链表
// 将结构体数组中所有结构体即节点链接起来，节点的数据默认设置为-1
void reserveArr(component* array)
{
    for (int i = 0; i < maxSize; i++)
    {
        array[i].cur = i + 1;//将每个结构体数组中每个结构体链接到一起
        array[i].data = -1;
    }
    array[maxSize - 1].cur = 0;//备用链表的最后一个结点的游标值为0
}

// 提取分配空间，从备用链表上摘下一个空闲节点，返回该空闲结点的下标
// 若备用链表非空，则将表头的游标指向下下一个空闲的节点;
// 若表链空，则返回0，即将表头这个空闲节点用于分配。
int mallocArr(component* array)
{
    int i = array[0].cur;
    if (array[0].cur) //若备用链表非空（即表头的游标≠0），则表头的游标指向下下一个空闲的节点
        array[0].cur = array[i].cur;
    return i;
}

// 从备用链表中申请内存，为数据链表赋初值
void initArr(component* array,int y[],int n)
{
    reserveArr(array);
    int tempBody = array[0].cur;
    int j;
    for (int i = 0; i < n; i++) 
    {
       j = mallocArr(array); //从备用链表中拿出空闲的分量,j=1,2,3,4
       array[j].data = y[i]; //给新申请的分量的数据域初始
       array[tempBody].cur = j;  //将申请的空闲分量链接在链表的最后一个结点后面
       tempBody = j;//将指向链表最后一个结点的指针后移
    }
    array[tempBody].cur = 0;  //将申请的空闲分量链接在链表的最后一个结点后面
}

//输出函数
void displayArr(component* array)
{
    for(int j=0;j<maxSize;++j)
        printf("a[%d],\tdata=%d\t,cur=%d\n",j, array[j].data, array[j].cur);
}

int main()
{
    int x[4] = { 3,1,4,5 };
    component array[maxSize];
    initArr(array, x,4);
    printf("静态链表为：\n");
    displayArr(array);
    return 0;
}

在这里插入图片描述

2.2 实例2 - 创建静态链表，默认值

#include <stdio.h>
#define maxSize 6

// 静态链表结构体
typedef struct
{
    int data; // 数据
    int cur;  // 游标，指向下一个存有数据的节点
}component;

// 创建备用链表
// 将结构体数组中所有结构体即节点链接起来，节点的数据默认设置为-1
void reserveArr(component* array)
{
    for (int i = 0; i < maxSize; i++)
    {
        array[i].cur = i + 1;//将每个结构体数组中每个结构体链接到一起
        array[i].data = -1;
    }
    array[maxSize - 1].cur = 0;//备用链表的最后一个结点的游标值为0
}

// 提取分配空间，从备用链表上摘下一个空闲节点，返回该空闲结点的下标
// 若备用链表非空，则将表头的游标指向下下一个空闲的节点;
// 若表链空，则返回0，即将表头这个空闲节点用于分配。
int mallocArr(component* array)
{
    int i = array[0].cur;
    if (array[0].cur) //若备用链表非空（即表头的游标≠0），则表头的游标指向下下一个空闲的节点
        array[0].cur = array[i].cur;
    return i;
}

// 从备用链表中申请内存，为数据链表赋初值
void initArr(component* array) 
{
    reserveArr(array);
    int tempBody = array[0].cur;
    int j;
    for (int i = 1; i < 4; i++) 
    {
       j = mallocArr(array); //从备用链表中拿出空闲的分量,j=1,2,3,4
       array[j].data = i; //给新申请的分量的数据域初始
       array[tempBody].cur = j;  //将申请的空闲分量链接在链表的最后一个结点后面
       tempBody = j;//将指向链表最后一个结点的指针后移
    }
    array[tempBody].cur = 0;  //将申请的空闲分量链接在链表的最后一个结点后面
}

//输出函数
void displayArr(component* array)
{
    for(int j=0;j<maxSize;++j)
        printf("a[%d],\tdata=%d\t,cur=%d\n",j, array[j].data, array[j].cur);
}

int main()
{
    component array[maxSize];
    initArr(array);
    printf("静态链表为：\n");
    displayArr(array);
    return 0;
}

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

【 3. 静态链表 添加元素 】

  • 在上图的基础，将元素 4 添加到静态链表中的第 3 个位置上，实现过程如下：
    • 从备用链表中摘除一个节点，用于存储元素 4；
    • 找到表中第 2 个节点（添加位置的前一个节点，这里是数据元素 2），将元素 2 的游标赋值给新元素 4；
    • 将元素 4 所在数组中的下标赋值给元素 2 的游标；
      在这里插入图片描述
  • C 语言实现以上操作：
//向链表中插入数据，body表示链表的头结点在数组中的位置，add表示插入元素的位置，a表示要插入的数据
void insertArr(component * array,int body,int add,char a)
{
    int tempBody=body;//tempBody做遍历结构体数组使用
    //找到要插入位置的上一个结点在数组中的位置
    for (int i=1; i<add; i++) 
        tempBody=array[tempBody].cur;
    int insert=mallocArr(array);//申请空间，准备插入
    array[insert].data=a;
    array[insert].cur=array[tempBody].cur;//新插入结点的游标等于其直接前驱结点的游标
    array[tempBody].cur=insert;//直接前驱结点的游标等于新插入结点所在数组中的下标
}

【 4. 静态链表 删除元素 】

  • 静态链表中删除指定元素，只需实现以下 2 步操作：
    • 将存有目标元素的节点从数据链表中摘除；
    • 将摘除节点添加到备用链表，以便下次再用；
  • 若问题中涉及大量删除元素的操作，建议在建立静态链表之初创建一个带有头节点的静态链表，方便实现删除链表中第一个数据元素的操作。
  • C 语言代码为：
//备用链表回收空间的函数，其中array为存储数据的数组，k表示未使用节点所在数组的下标
void freeArr(component * array,int k)
{
    array[k].cur=array[0].cur;
    array[0].cur=k;
}
//删除结点函数，a 表示被删除结点中数据域存放的数据
void deletArr(component * array,int body,char a)
{
    int tempBody=body;
    //找到被删除结点的位置
    while (array[tempBody].data!=a) 
    {
        tempBody=array[tempBody].cur;
        //当tempBody为0时，表示链表遍历结束，说明链表中没有存储该数据的结点
        if (tempBody==0) 
        {
            printf("链表中没有此数据");
            return;
        }
    }
    //运行到此，证明有该结点
    int del=tempBody;
    tempBody=body;
    //找到该结点的上一个结点，做删除操作
    while (array[tempBody].cur!=del) 
    {
        tempBody=array[tempBody].cur;
    }
    //将被删除结点的游标直接给被删除结点的上一个结点
    array[tempBody].cur=array[del].cur;
    //回收被摘除节点的空间
    freeArr(array, del);
}

【 5. 静态链表 查找元素 】

  • 静态链表查找指定元素，由于我们只知道静态链表第一个元素所在数组中的位置，因此只能通过逐个遍历静态链表的方式，查找存有指定数据元素的节点。
  • C 语言实现代码如下：
//在以body作为头结点的链表中查找数据域为elem的结点在数组中的位置
int selectElem(component * array,int body,char elem)
{
    int tempBody=body;
    //当游标值为0时，表示链表结束
    while (array[tempBody].cur!=0) 
    {
        if (array[tempBody].data==elem) 
            return tempBody;
        tempBody=array[tempBody].cur;
    }
    return -1;//返回-1，表示在链表中没有找到该元素
}

【 6. 静态链表 更改数据 】

  • 更改静态链表中的数据，只需找到目标元素所在的节点，直接更改节点中的数据域即可。
  • C 语言代码如下：
//在以body作为头结点的链表中将数据域为oldElem的结点，数据域改为newElem
void amendElem(component * array,int body,char oldElem,char newElem)
{
    int add=selectElem(array, body, oldElem);
    if (add==-1)
     {
        printf("无更改元素");
        return;
    }
    array[add].data=newElem;
}

【 7. 实例 - 静态链表的增删查改 】

#include <stdio.h>
#define maxSize 7

//静态链表结构体
typedef struct 
{
    char data;
    int cur;
}component;

//创建备用链表
//将结构体数组中所有分量链接到备用链表中
void reserveArr(component* array) 
{
    for (int i = 0; i < maxSize; i++) 
    {
        array[i].cur = i + 1;//将每个数组分量链接到一起
        array[i].data = ' '; // 默认赋值为空格
    }
    array[maxSize - 1].cur = 0;//链表最后一个结点的游标值为0
}

//从备用链表中摘除空闲节点的实现函数
//提取分配空间
int mallocArr(component* array)
{
    //若备用链表非空，则返回分配的结点下标，否则返回0（当分配最后一个结点时，该结点的游标值为0）
    int i = array[0].cur;
    if (array[0].cur)
        array[0].cur = array[i].cur;
    return i;
}

//将摘除下来的节点链接到备用链表上
void freeArr(component* array, int k)
{
    array[k].cur = array[0].cur;
    array[0].cur = k;
}

//初始化静态链表
int initArr(component* array)
{
    reserveArr(array);
    int body = mallocArr(array);
    //声明一个变量，把它当指针使，指向链表的最后的一个结点，因为链表为空，所以和头结点重合
    int tempBody = body;
    for (int i = 1; i < 5; i++) 
    {
        int j = mallocArr(array);//从备用链表中拿出空闲的分量
        array[tempBody].cur = j;//将申请的空线分量链接在链表的最后一个结点后面
        array[j].data = 'a' + i - 1;//给新申请的分量的数据域初始化
        tempBody = j;//将指向链表最后一个结点的指针后移
    }
    array[tempBody].cur = 0;//新的链表最后一个结点的指针设置为0
    return body;
}

//向链表中插入数据，body表示链表的头结点在数组中的位置，add表示插入元素的位置，a表示要插入的数据
void insertArr(component* array, int body, int add, char a)
{
    int tempBody = body;
    for (int i = 1; i < add; i++)
        tempBody = array[tempBody].cur;
    int insert = mallocArr(array);
    array[insert].cur = array[tempBody].cur;
    array[insert].data = a;
    array[tempBody].cur = insert;
}

//删除链表中含有字符a的结点
void deletArr(component* array, int body, char a)
{
    int tempBody = body;
    //找到被删除结点的位置
    while (array[tempBody].data != a)
    {
        tempBody = array[tempBody].cur;
        //当tempBody为0时，表示链表遍历结束，说明链表中没有存储该数据的结点
        if (tempBody == 0)
        {
            printf("链表中没有此数据");
            return;
        }
    }
    //运行到此，证明有该结点
    int del = tempBody;
    tempBody = body;
    //找到该结点的上一个结点，做删除操作
    while (array[tempBody].cur != del)
    {
        tempBody = array[tempBody].cur;
    }
    //将被删除结点的游标直接给被删除结点的上一个结点
    array[tempBody].cur = array[del].cur;

    freeArr(array, del);
}

//查找存储有字符elem的结点在数组的位置
int selectElem(component* array, int body, char elem)
{
    int tempBody = body;
    //当游标值为0时，表示链表结束
    while (array[tempBody].cur != 0)
    {
        if (array[tempBody].data == elem)
            return tempBody;
        tempBody = array[tempBody].cur;
    }
    return -1;//返回-1，表示在链表中没有找到该元素
}

//将链表中的字符oldElem改为newElem
void amendElem(component* array, int body, char oldElem, char newElem)
{
    int add = selectElem(array, body, oldElem);
    if (add == -1)
    {
        printf("无更改元素");
        return;
    }
    array[add].data = newElem;
}

//输出函数
void displayArr(component* array, int body)
{
    int tempBody = body;//tempBody准备做遍历使用
    while (array[tempBody].cur)
    {
        printf("%c,%d \n", array[tempBody].data, array[tempBody].cur);
        tempBody = array[tempBody].cur;
    }
    printf("%c,%d\n", array[tempBody].data, array[tempBody].cur);
}

int main() 
{
    component array[maxSize];
    int body = initArr(array);
    printf("静态链表为：\n");
    displayArr(array, body);

    printf("在第3的位置上插入结点‘e’:\n");
    insertArr(array, body, 3, 'e');
    displayArr(array, body);

    printf("删除数据域为‘a’的结点:\n");
    deletArr(array, body, 'a');
    displayArr(array, body);

    printf("查找数据域为‘e’的结点的位置:\n");
    int selectAdd = selectElem(array, body, 'e');
    printf("%d\n", selectAdd);
    printf("将结点数据域为‘e’改为‘h’:\n");
    amendElem(array, body, 'e', 'h');
    displayArr(array, body);
    return 0;
}

在这里插入图片描述

MR_Promethus
关注
  • 21
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
C语言数据结构静态链表
l233477的博客
04-23 120
作业代码运行结果。
数据结构_静态链表(C语言)
小黯
04-02 3196
目录一、静态链表图文解析二、静态链表代码解析1、基本操作1.1 结构1.2 初始化1.3 插入数据1.4 删除数据1.5 修改数据2、源代码及测试2.1 源代码2.2 测试结果 一、静态链表图文解析 二、静态链表代码解析 1、基本操作 1.1 结构 1.2 初始化 1.3 插入数据 1.4 删除数据 1.5 修改数据 2、源代码及测试 2.1 源代码 2.2 测试结果 ...
5，C语言数据结构 静态链表
Scroll_C的博客
11-28 291
静态链表及其创建 静态链表，也是线性存储结构的一种，它兼顾了顺序表和链表的优点于一身，可以看做是顺序表和链表的升级版。使用静态链表存储数据，数据全部存储在数组中（和顺序表一样），但存储位置是随机的，数据之间"一对一"的逻辑关系通过一个整形变量（称为"游标"，和指针功能类似）维持（和链表类似）。 例如，使用静态链表存储{1,2,3}的过程如下： 创建一个足够大的数组，假设大小为 6，如图 1 所示： 图 1 空数组 接着，在将数据存放到数组中时，给各个数据...
6.C语言数据结构 静态链表基本操作
Scroll_C的博客
11-29 623
本节是建立在已能成功创建静态链表的基础上，因此我们继续使用上节中已建立好的静态链表学习本节内容，建立好的静态链表如图 1 所示： 图 1 建立好的静态链表 静态链表添加元素 例如，在图 1 的基础，将元素 4 添加到静态链表中的第 3 个位置上，实现过程如下： 从备用链表中摘除一个节点，用于存储元素 4； 找到表中第 2 个节点（添加位置的...
数据结构之静态链表
热门推荐
m0_64365419的博客
08-20 1万+
静态链表：分配一整片连续的内存空间，各个结点集中安置，逻辑结构上相邻的数据元素，存储在指定的一块内存空间中，数据元素只允许在这块内存空间中随机存放，这样的存储结构生成的链表称为静态链表。也就是说静态链表是用数组来实现链式存储结构，静态链表实际上就是一个结构体数组举例：通过a[1]中存放的游标变量3可找到存放的数据元素5的后继元素为3，再通过a[3]中存放的游标变量2可找到存放数据元素3的后继数据为2，以此类推，直到某元素的游标变量为0即可停止（注：a[0]为头结点不存储数据元素）
C语言数据结构 静态链表
04-14
我的数据结构作业，静态链表。望大家指点一二
c语言实现静态链表
03-17
c语言实现的静态链表
数据结构(C语言版)---静态链表
09-21
数据结构(C语言版)---静态链表。这是博客配套代码。如果代码中有什么错误欢迎大家指出·············
数据结构，含有多个主链表和一个备用链表的静态链表 本文件对应严蔚敏与吴伟明编著的数据结构的静态链表
02-09
数据结构，含有多个主链表和一个备用链表的静态链表。本文件对应严蔚敏与吴伟明编著的数据结构的静态链表。
【数据结构】二叉树（带图详解）
Z1tai的博客
04-27 1541
链表和数组都是线性结构，而树是非线性的结构。树是依靠分支关系定义出的一种层次结构。社会亲缘关系和组织结构图都可以用树来形象地表示。
数据结构系列-二叉树之前序遍历
in_seattle的博客
04-26 504
这篇文章，我们主要的内容是对二叉树当中的前历的算法进行讲解，二叉树中的算法所要求实现的是 从根到左子树再到右子树的遍历顺序，可能这样不太好理解，我们拿一张图片进行解释，我们先来分析一下这个的实现逻辑是什么，按照根节点，左子树，右子树的顺序，我们先来判断一下这个应该实现的结果是什么。在这里，我们将空也表现了出来，那下面，我们就讲解一下怎么用代码实现这个过程。假设在这个二叉树当中，我们要实现二叉树遍历当中的前历，我们应该怎么做呢。这些代码我们在前面就详细的进行了展开，在这里我们就不进行详细的讲解。
【数据结构】第二章 线性数据结构.线性表.顺序表
KX_52517的博客
04-26 1347
线性数据结构章节
【数据结构】图（Graph）
2201_75475240的博客
04-24 1300
本文章介绍数据结构中的图的基本知识，包括概念、邻接表、邻接矩阵、深度遍历和广度遍历，且还包含408习题（附有解析）。此外，含有关于邻接表和两种遍历全部具体实现代码。
数据结构练习：链表扩容
2301_80369371的博客
04-25 332
一：创建一个新链表，遍历原链表的同时，将原链表的值复制给新链表。二：将新链表插入到原链表中（大致如下）3.*&是c++的写法，等同于c中的*2.记得malloc后要free。1.头结点是不存有数据的。
数据结构(八)——排序
señoritaw的博客
04-25 1099
排序(Sort)，就是重新排列表中的元素，使表少的元素满足按关键字有序的过程。输入∶n个记录R1,R2...., Rn，对应的关键字为k1, k2,... , kn输出:输入序列的一个重排R1',R2'....,Rn'，使得有k1'≤k2'≤...≤kn'(也可递减)算法的稳定性。若待排序表中有两个元素R,和R，其对应的关键字相同即key = keyj，且在排序前R;在R,的前面，若使用某一排序算法排序后，R仍然在R的前面，则称这个排序算法是稳定的，否则称排序算法是不稳定的。
排序-八大排序FollowUp
最新发布
2301_78838401的博客
04-27 977
最坏情况下:0(n^2)最好情况下:0(n)当数据越有序 排序越快适用于: 待排序序列 已经基本上趋于有序了!空间复杂度:0(1)稳定性:稳定的。
【C 数据结构】二叉树
普罗米修斯的博客
04-24 1087
性质 3 的计算方法为：对于一个二叉树来说，除了度为 0 的叶子结点和度为 2 的结点，剩下的就是度为 1 的结点（设为。同时，对于每一个结点来说都是由其父结点分支表示的，假设树中分枝数为 B，那么总结点数。例如，图 1a) 就是一棵二叉树，而图 1b) 则不是。而分枝数是可以通过 n1 和 n2 表示的，即。两种方式得到的 n 值组成一个方程组，就可以得出。所以，n 用另外一种方式表示为。使用顺序表（数组）存储二叉树。顺序存储只适用于完全二叉树。满二叉树也是完全二叉树。每个结点的度都为 2。
数据结构系列-堆排序当中的T-TOK问题
in_seattle的博客
04-24 329
在这个代码当中有几个比较厉害的点需要我们注意一下，首先在他的创建数据的那个阶段，我们使用了随机数，但是它那里进行了取余，这样的好处是将数字的范围控制在一个程度之内，可以检测自己的程序是否正确表达。T-TOK说简单点，就是说，假如有10000个数据（随机的），让你找到其中最大的10个数据，有什么快速的方法，遍历吗？这个是不显示的，效率是最低的。之前我们讲到了堆排序的实现逻辑，那么接下来我们重点关注的就是其中的T-TOK问题。所以，我们能想到的比较好的方法就是堆排序当中的T-TOK问题。
静态链表和动态链表的区别
07-28
在插入和删除操作时，静态链表只需要修改游标，不需要移动元素，从而改进了在顺序存储结构中插入和删除元素需要移动大量元素的缺点。但静态链表没有解决连续存储分配带来的表长难以确定的问题。\[1\] 总结来说，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

MR_Promethus

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

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

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

打赏作者

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

抵扣说明：

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

余额充值