数据结构学习笔记（2）--链表

最新推荐文章于 2024-07-08 21:10:38 发布
最新推荐文章于 2024-07-08 21:10:38 发布
阅读量741 收藏 9
点赞数 23
文章标签： 数据结构 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81135589/article/details/138923134
版权

1.单链表

优点：不要求大片连续空间，改变容量方便。

缺点：不可随机存取，要耗费一定空间存放指针。

用代码定义一个链表

struct LNode{
    ElemType data;    //数据域
    struct LNode *next;    //指针域
}

增加一个新的结点：在内存中申请一个结点所需空间，并用指针p指向这个结点。

struct LNode *p = (struct LNode *)malloc(sizeof(struct LNode));

typedef给数据类型重命名

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;    //将单链表名字定义为LNode，LinkList为一个指向struct LNode的指针

声明一个指向单链表第一个结点的指针：

LNode * L；或 LinkList L；这两种表示方法本质上是一样大，但是为了使代码的可读性更强，我们往往使用LNode *强调返回的是一个结点，LinkList强调这是一个单链表。

（1）不带头结点的单链表

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//初始化一个空的单链表
bool InitList(LinkList &L){
    L = NULL;    //空表，暂时还没有任何结点
    return true;
}

void test(){
    LinkList L;    //声明一个指向单链表的指针
    //初始化一个空表
    InitList(L);
}

（2）带头结点的单链表

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//初始化一个单链表（带头结点）
bool InitList(LinkList &L){
    L=(LNode *)malloc(sizeof(LNode));    //分配一个头结点
    if(L==NULL)    //内存不足分配失败
        return false;
    L->next = NULL;    //头结点之后暂时还没有结点
    return true;
}

void test(){
    LinkList L;    //声明一个指向单链表的指针
    InitList(L);    //初始化一个空表
    //后续代码....
}

（3）单链表的插入

按位序插入（带头结点）

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//在第i个位置插入元素e（带头结点）
bool ListInsert(LinkList &L,int i,ElemType e){
    if(i<1)
        return false;
    LNode *p;    //指针p指向当前扫描到的结点
    int j=0;    //当前p指向的是第几个结点
    p = L;    //L指向头结点，头结点是第0个结点（不存数据）
    while(p!=NULL && j<i-1){
        //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL)    //i值不合法
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;    //将结点s连到p之后
    return true;    //插入成功
}

注意：这两行代码顺序不能写反

s->next = p->next;
p->next = s;

按位序插入（不带头结点）

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

bool ListInsert(LinkList &L,int i,ElemType e){
    if(i<1)
        return false;
    if(i==1){
//插入第1个结点的操作与其他结点操作不同
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = L;
    L=s;    //头指针指向新结点
    return true;
    }
    Lnode *p;    //指针p指向当前扫描到的结点
    int j=1;    //当前p指向的是第几个结点
    p=L;    //p指向第一个结点（不是头结点）
    while(p!=NULL && j<i-1){
    //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL)
        return false;    //i值不合法
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;    //插入成功
}

指定结点的后插操作

//后插操作：在p结点之后插入元素e
bool InsertNode (LNode *p,ElemType e){
    if(p==NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s==NULL)    //若内存不足可能分配失败
        return false;
    s->data = e;    //用结点s保存数据元素e
    s->next=p->next;
    p->next=s;    //将结点s连到p之后
    return true;
}

指定结点的前插操作

方法一：

bool InsertPriorNode (LNode *p,ElemType e){
    if(p==NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s==NULL)    //内存分配失败
        return false;
    s->next = p->next;
    p->next = s;    //新结点s连到p之后
    s->data = p->data;    //将p中元素复制到s中
    p->data = e;    //p中元素覆盖为e
    return true;
}

方法二：

bool InsertPriorNode(LNode *p, LNode *s){
    if(p == NULL||s==NULL)
        return false;
    s->next = p->next;
    p->next = s;    //s连到p之后
    ElemType temp = p->data;    //交换数据域部分
    p->data = s->data;
    s->data = temp;
    return true;
}

（4）单链表的删除

按位序删除（带头结点）

typedef struct LNode{
    ELemType data;
    struct LNode *next;
}LNode,*LinkList;

bool ListDelete(LinkList &L,int i,ELemType &e){
    if(i<1)
        return false;
    LNode *p;    //指针p指向当前扫描到的结点
    int j=0;
    p = L;
    while(p!=NULL && j<i-1){
    //循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL)
        return false;
    if(p->next == NULL)    //第i-1个结点之后已无其他结点
         return false;
    LNode *q = p->next;    //令q指向被删除结点
    e = q->data;    //e返回元素的值
    p->next = q->next;    //将*q结点从链中断开
    free(q);    //释放结点的内存空间
    return true;
}

指定结点的删除

//删除指定结点p
bool DeleteNode(LNode *p){
    if(p == NULL)
        return false;
    LNode *q = p->next;    //令q指向*p的后继结点
    p->data = p->next->data;    //和后继结点交换数据域
    p->next = q->next;    //将*q结点从链中断开
    free(p);    //释放后继结点的存储空间
    return true;
}

如果p是最后一个结点只能从表头开始依次寻找p的前驱。

单链表的局限性：无法逆向检索，有时候不太方便。

（5）单链表的查找

按位查找

//按位查找，返回第i个元素（带头结点）
LNode * GetElem(LinkList L,int i){
    if(i<0)
        return NULL;
    LNode *p;    //指针p指向当前扫描到的结点
    int j=0;    //当前p指向的是第几个结点
    p = L;
    while(p!=NULL && j<i){
        p = p->next;
        j++;
    }
    return p;
}

 按值查找

//按值查找，找到数据域==e的结点
LNode * LocateElem(LinkList L,ElemType e){
    LNode *p = L->next;
    //从第一个结点开始查找数据域为e的结点
    while(p != NULL && p->data != e)
        p = p->next;
    return p;    //找到后返回该指针否则返回NULL
}

（6）求单链表的长度

//求表的长度
int length(LinkList L){
    int len = 0;    //统计表长
    LNode *p = L;
    while(p->next !=NULL){
        p=p->next;
        len++;
    }
    return len;
}

（7）单链表的建立

step1：初始化一个单链表

step2：每次取一个数据元素，插入到表尾/表头

①尾插法

先初始化单链表

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

//初始化一个单链表（带头结点）
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));
    if(L==NULL)    //内存不足，分配失败
        return false;
    L->next = NULL;    //头结点之后暂时还没有结点
    return true;
}

void test(){
    LinkList L;    //声明一个指向单链表的指针
    //初始化一个空表
    InitList(L);
}

设置变量length记录链表长度

使用while循环

while{
    //每次取一个数据元素e;
    ListInsert(L,length+1,e);  //插到尾部;
    length++;
}

尾插法建立单链表完整代码：

LinkList List_Tailnsert(LinkList &L){    //正向建立单链表
    int x;                               //设ElemType为整型
    L = (LinkList)malloc(sizeof(LNode)); //建立头结点
    LNode *s,*r = L;                     //r为表尾指针
    scanf("%d",&x);                      //输入结点的值
    while(x!=9999){                      //输入9999表示结束
        s=(LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;                           //r指向新的表尾结点
        scanf("%d",&x);
    }
    r->next = NULL;                      //尾结点指针置空
    return L;
}

②头插法

LinkList List_HeadInsert(LinkList &L){    //逆向建立链表
    LNode *s;
    int x;
    L = (LinkList)malloc(sizeof(LNode));  //创建头结点
    L->next = NULL;                       //初始为空链表
    scanf("%d",&x);                       //输入结点的值
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));  //创建新结点
        s->data = x;
        s->next = L->next;
        L->next = s;                      //将新结点插入表中，L为头指针
        scanf("%d",&x);
    }
}

注意：头插法的重要应用：链表的逆置

2.双链表

（1）双链表既有后继指针也有前驱指针

typedef struct DNode{    //定义双链表结点类型
    ElemType data;    //数据域
    struct DNode *prior,*next;    //前驱指针和后继指针
}DNode,*DLinkList;

（2）双链表的初始化

typedef struct DNode{
    ElenType data;
    struct DNode *prior,*next;
}DNode,*DLinkList;

//初始化双链表
bool InitDLinkList(DLinkList &L){
    L = (DNode *)malloc(sizeof(DNode));    //分配一个头结点
    if (L == NULL)    //内存不足，分配失败
        return false;
    L->prior = NULL;    //头结点的prior永远指向NULL
    L->next = NULL;    //头结点之后暂时还没有结点
}

void testDLinkList(){
    //初始化双链表
    DLinkList L;
    InitDLinkList(L);
    //后续代码
}

（3）双链表的插入

//在p结点之后插入s结点
bool InsertNextNode(DNode *p, DNode *s){
    if(p == NULL || s == NULL)    //非法参数
        return false;
    s->next = p->next;    //将结点*s插入到结点*p之后
    if (p->next != NULL)    //如果p结点有后继结点
        p->next->prior = s;
    s->prior = p;
    p->next = s;
}

（4）双链表的删除

//删除p结点的后继结点
bool DeleteNextDNode(DNode *p){
    if (p == NULL)
        return false;
    DNode *q = p->next;    //找到p的后继结点q
    if (q == NULL)
        return false;    //p没有后继
    p->next = q->next;
    if(q->next!=NULL)
        q->next->prior=p;
    free(q);    //释放空结点
    return true;
}

销毁一个双链表

void DestoryList(DLinkList &L){
    //循环释放各个数据结点
    while (L->next != NULL)
        DeleteNextDNode(L);
    free(L);    //释放头结点
    L = NULL;    //头指针指向NULL
}

（5）双链表的遍历

①后向遍历

while(p!=NULL){
    //对结点p做相应处理，如打印
    p = p->next;
}

②前向遍历

while(p!=NULL){
    //对结点p做相应处理
    p = p->prior;
}

③前向遍历（跳过头结点）

while(p->prior != NULL){
    //对结点p做相应处理
    p=p->prior;
}

双链表不可随机存取，按位查找、按值查找操作都只能用遍历的方式实现。

3.循环链表

（1）循环单链表

在初始化时头结点的next指针需要指向它自己。

typedef struct LNode{    //定义单链表结点类型
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

//初始化一个循环单链表
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));    // 分配一个头结点
    if(L == NULL)    //内存不足，分配失败
        return false;
    L->next = L;    //头结点next指向头结点
    return true;
}

//判断循环单链表是否为空
bool Empty (LinkList L){
    if(L->next == L)
        return true;
    else
        return false;
}

//判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L,LNode *p){
    if (p->next == L)
        return true;
    else
        return false;
}

（2）循环双链表

表头结点的prior指向表尾节点，表尾结点的next指向头结点。

循环双链表的初始化

typedef struct DNode{
    ElemType data;
    struct DNode *prior,*next;
}DNode,*DLinkList;

//初始化空的循环双链表
bool InitDLinkList(DLinkList &L){
    L = (DNode *)malloc(sizeof(DNode));    //分配一个头结点
    if(L == NULL)    //内存不足，分配失败
        return false;
    L->prior = L;    //头结点的prior指向头结点
    L->next = L;    //头结点的next指向头结点
    return true;
}

void testDLinkList(){
    //初始化循环双链表
    DLinkList L;
    InitDLinkList(L);
    //...后续代码...
}

//判断循环双链表是否为空
bool Empty(DLinkList L) {
    if (L->next == L)
        return true;
    else
        return false;
}

//判断p结点是否为循环双链表的表尾结点
bool isTail (DLinkList L,DNode *p){
    if (p->next == L)
        return true;
    else
        return false;
}

双链表的插入

//在p结点之后插入s结点
bool InertNextDNode(ONode *p，DNode *s){
    s->next = p->next;
    p->next->prior = s;
    s->prior = p;
    p->next = s;
}

双链表的删除

//删除p的后继结点q
p->next = q->next;
q->next->prior = p;
free(q);

4.静态链表

（1）定义一个静态链表

定义一个结点

#define MaxSize 10    //静态链表的最大长度
struct Node{    //静态链表结构类型的定义
    ElemType data;    //存储数据元素
    int next;    //下一个元素的数组下标
};

定义多个连续存放的结点

void testLinkList(){
    struct Node a[MaxSize];
    //...后续代码
}

一个特殊的定义方法

#define MaxSize 10
typedef struct{
    ElemType data;
    int next;
}SLinkList[MaxSize];

在初始化的时候可以让next为某个特殊值，如-2，防止“脏数据”

（2）简述基本操作的实现

①初始化静态链表：

把a[0]的next设为-1

②查找某一个位序的结点：

从头结点出发挨个往后遍历结点

③插入位序为i的结点：

找到一个空的结点，存入数据元素；

从头结点出发找到位序为i-1的结点；

修改新结点的next为-1；

修改i-1号结点的next

注意：静态链表的容量固定不变

iamyuanchu
关注
  • 23
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构学习笔记-单链表
02-16
本学习笔记将聚焦于单链表的概念、操作以及在VS2022环境下如何实现。 单链表是一种线性数据结构，其元素（节点）不是在内存中连续存储的，而是通过指针链接在一起。每个节点包含两部分：数据域和指针域。数据域用于...
算法数据结构学习笔记-C语言.zip
06-16
"算法数据结构学习笔记-C语言.zip"这个压缩包很可能是为大学生提供的一份详细的学习资源，涵盖了数据结构的基础知识、常见算法以及相关的实践练习。 首先，我们要理解数据结构的基本概念，如数组、链表、栈、队列、...
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 40万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
Java数据结构学习笔记----链表与递归(三)
m0_75113406的博客
05-25 153
操作： addHead() addTail() add()学习链表有助于学习后续更复杂的动态数据结构。关键点：找到要待添加位置的前一个结点。注意： 添加完成后，需要更新头节点。toString()【遍历链表】优点：不需要处理固定容量的问题。学习链表有助于更好的学习递归。以链表作为栈的底层数据结构。链表是最简答的动态数据结构。缺点：丧失了随机访问的能力。<3>在链表的尾部添加元素。<1> 链表头添加元素。<2>链表中间添加元素。
数据结构与算法学习笔记
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构学习笔记 1-1链表概述及LeetCode真题图解（Java）(2)
2401_84023482的博客
05-03 903
对于面试还是要好好准备的，尤其是有些问题还是很容易挖坑的，例如你为什么离开现在的公司（你当然不应该抱怨现在的公司有哪些不好的地方，更多的应该表明自己想要寻找更好的发展机会，自己的一些现实因素，比如对于我而言是现在应聘的公司离自己的家更近，又或者是自己工作到达了迷茫期，想跳出迷茫期等等）Java面试精选题、架构实战文档你的支持，我的动力；祝各位前程似锦，offer不断！
数据结构学习笔记 1-1链表概述及LeetCode真题图解（Java）(3)
2401_84023482的博客
05-03 807
上述知识点，囊括了目前互联网企业的主流应用技术以及能让你成为“香饽饽”的高级架构知识，每个笔记里面几乎都带有实战内容。很多人担心学了容易忘，这里教你一个方法，那就是重复学习。打个比方，假如你正在学习 spring 注解，突然发现了一个注解@Aspect，不知道干什么用的，你可能会去查看源码或者通过博客学习，花了半小时终于弄懂了，下次又看到@Aspect 了，你有点郁闷了，上次好像在哪哪哪学习，你快速打开网页花了五分钟又学会了。从半小时和五分钟的对比中可以发现多学一次就离真正掌握知识又近了一步。
数据结构看书笔记---lazyfennec整理精选
11-15
"数据结构看书笔记---lazyfennec整理精选"是一份由lazyfennec精心整理的数据结构学习资料，旨在帮助学习者深入理解并掌握这一领域的重要概念和算法。 笔记可能涵盖了以下几个关键知识点： 1. **数组**：数组是最...
Redis原理-数据结构
最新发布
略
07-08 626
Redis原理篇 1、原理篇-Redis数据结构 1.1 Redis数据结构-动态字符串 我们都知道Redis中保存的Key是字符串，value往往是字符串或者字符串的集合。可见字符串是Redis中最常用的一种数据结构。 不过Redis没有直接使用C语言中的字符串，因为C语言字符串存在很多问题： 获取字符串长度的需要通过运算 非二进制安全 不可修改 Redis构建了一种新的字符串结构，称为简单动态字符串（Simple Dynamic String），简称SDS。 例如，我们执行命令： 那么
6、Redis系统-数据结构-06-跳表
qq_29434541的博客
07-07 429
在 Redis 中，跳表通过高效的多级链表结构，实现了有序集合的快速插入、删除和查询操作，适用于需要有序数据存储的场景。跳表通过多级链表的形式实现，每一级链表都跳过一些元素，从而在查询时能够快速跳过不必要的元素。跳表的每个节点包含一个或多个前进指针，这些前进指针指向不同级别的节点，使得跳表具有高效的查询性能。删除节点时，通过查找操作确定节点位置，然后在每一级链表中移除该节点，并调整相关节点的前进指针和跨度。插入新节点时，首先确定新节点的级别，然后在每一级链表中找到插入位置，将新节点插入到相应的位置。
【数据结构】（6.3）堆的应用——堆排序（C语言）
金哥的博客
07-05 353
堆排序（Heap Sort）就是对直接选择排序的一种改进。此话怎讲呢？直接选择排序在待排序的n个数中进行n-1次比较选出最大或者最小的，但是在选出最大或者最小的数后，并没有对原来的序列进行改变，这使得下一次选数时还需要对全部数据进行比较，效率大大降低。堆排序算法是Floyd和Williams在1964年共同发明的，同时他们发明了“堆”这种数据结构。
【数据结构】12.排序
2301_80258336的博客
07-08 470
常见的排序算法详解
数据结构第07节：队列
hummhumm的专栏
07-04 471
在计算机科学中，队列是一种抽象数据类型，它遵循先进先出（FIFO）原则，即最先加入队列的元素将是最先被移除的。在学生成绩管理系统中，队列可以用于管理等待处理的成绩更新请求，或者用于存储等待查询成绩的学生ID列表。请注意，这个实现假设所有学生ID都是整数，并且队列的大小是固定的。这个队列将用于管理学生的ID，模拟学生成绩管理系统中可能用到的队列操作。下面，我将以一个简单的学生成绩管理系统中的队列应用为例，用表格形式来详细讲解队列的操作和状态变化。类，它包含书籍的基本信息，例如书名、作者和ISBN号。
数据结构中第05节：链表
hummhumm的专栏
07-03 721
数据结构中的链表是一种重要的数据组织方式，它由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。链表的灵活性和动态性使其在很多实际应用中非常有用，包括生活中的一些场景和游戏中。
数据结构：排序
2402_82670467的博客
07-08 493
1.直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用2.时间复杂度：O(N^2)3.空间复杂度：O(1)4.稳定性：不稳定代码实现：我们先来实现单趟排序，我们定义一个变量begin和一个变量mini（其中mini是最小数字的下标，begin是依次排序时的下标）先遍历一遍找到最小的，将其下标赋值给mini，循环结束后，将下标为begin和mini的两个数字交换，然后begin++接下来找第二小的，重复以上步骤。
(三)前端javascript中的数据结构之链表上
峰会路转的博客
07-08 212
在js中，没有为我们提供原生的数据结构支持的，但是在java中是有提供的。所以需要我们去模拟这种结构实现。链表中最关键的一个元素，就是头节点，头节点不存储数据，指向第一个节点链表中几乎所有的操作都要从头结点开始。
【数据结构】线性表----栈详解
Skrrapper的博客
07-08 912
栈（Stack）是一种常见的数据结构，它具有**后进先出（Last In, First Out, LIFO）**的特点。栈的运作类似于物理世界中的叠盘子：最新放上去的盘子最先被拿走，而最底部的盘子最后才能被取出。如果你先拿底下的盘子，那么就有可能出现整个盘子组全部倒塌碎落一地——这也就是所谓的栈出错。栈有着的特点。所以它的出栈和入栈也遵循着这个特点。我们在存取元素的时候，一般是在进行——也就是所谓的盘子顶；而另一端称为，一般就是数据结构的头结点。入栈出栈的顺序只需记住：顺序必须有规律，例如。
数据结构--顺序表
LH__1314的博客
06-30 4564
当我们想要使⽤大量使⽤同⼀类型的数据时，通过⼿动定义⼤量的独立的变量对于程序来说，可读性非常差，我们可以借助数组这样的数据结构将⼤量的数据组织在⼀起，结构也可以理解为组织数据的方式。在使用完顺序表后，就要销毁顺序表，因为动态顺序表内存是动态开辟的，所以需要对动态内存进行释放，并将有效数据和空间容量个数置为0；到这里，顺序表的知识就完成了，学完这些，我们也要写顺序表的实践，就是通讯录——在下一篇进行实现。求数组的长度，求数组的有效数据个数，向下标为数据有效个数的位置插入数据（注意：这里是。
数据结构第15节 最小生成树
hummhumm的专栏
07-08 824
最小生成树（Minimum Spanning Tree, MST）是指在一个连通的带权无向图中，由所有顶点构成的一棵树，其所有的边的权重之和最小。最小生成树在实际中有许多应用，比如网络设计、城市规划中的电线或水管铺设等。有两种著名的算法用于寻找最小生成树：Prim算法和Kruskal算法。
数据结构学习笔记.docx
12-02
《数据结构学习笔记.docx》是一份包含关于算法时间复杂度、空间复杂度以及线性表的基本特点和存储结构的学习笔记。在学习笔记中提到，算法的时间复杂度T(n)表示算法执行时间的增长率和问题规模n的增长率相同，用O(f...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值