数据结构之单链表（笔记）

已于 2024-08-14 19:45:21 修改
阅读量368 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c语言 链表
于 2023-03-22 15:38:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ztt19990421/article/details/129538033
版权

一、顺序表与链表的优缺点

顺序表缺陷：1.空间不够了要增容，增容要付出代码；原地扩容代价低，异地扩容代价高。

2.避免频繁扩容，满了基本都是扩2倍，可能会导致一定的空间浪费。

3.顺序表要求数据从开始位置连续存储，那么我们在头部活中间位置插入删除数据就需要挪动数据，效率不高。

顺序表的优点：支持随机访问，有些算法，需要结构支持随机访问，如：二分查找、优化的快排等。

针对顺序表的缺陷，设计出了链表。

链表的优点：按需申请空间，不用就释放（更合理的使用了空间）；头部中间插入删除数据，不需要挪动数据； 不存在空间浪费。

链表的缺点：每一个数据，都要存一个指针去链接后面数据节点；不支持随机访问（用下标直接访问第i个）。

单链表的缺陷还是很多，单纯单链表增删查找的意义不大

1、很多题考察的都是单链表；

2、单链表更多的是去更复杂数据结构的子结构，如哈希桶，邻接表。

链表存储数据还要看双向链表。

二、单链表定义的相关代码

 单链表尾插法

//单链表尾插法
void SListPushBack(SLTNode* phead SLTDateType x)
{
    //找到尾结点
    SLTNode* tail=phead;//从第一个结点开始
    while(tail->next!=NULL)
    {
        tail=tail->next;//找到最后一个结点
    }
    SLTNode* newnode=(SLTNode*)malloc(sizeof(SLTNode));//开辟一个新结点存放x的值
    newnode->data=x;/
    newnode->next=NULL;//newnode存放完x的值后，作为最后一个结点，指向NULL
    tail->next=newnode;//与链表连接
}

//SList.h文件
typedef int SLDateType;
typedef struct SListNode
{
   SLdateType data;
   struct SListNode* next;
}SListNode;
void SListPrint(SLTNode* phead);
void SListPushBack(SLTNode** pphead,SLTDateType x);
void SListPushFront(SLTNode** pphead,SLTDateType x);
void SListpopBack(SLTNode** pphead);
void SListpopFront(SLTNode** pphead);
SLTNode* SListFind(SLTNode* phead,SLTDateType x);
void SListInsert(SLTNode** phead,SLTNode* pos,SLTDateType x);
void SListInsertAfter(SLTNode* pos,SLTDateType x)；
void SListErase(SLTNode** phead,SLTNode* pos)；
void SListErase(SLTNode** phead,SLTNode* pos);
void SListDestory(SLTNode** phead);
#pragma once
#include <stdio.h>
typedef int SLTDateType;//SLDataType的作用等同于int，当数据的类型要变成char或者double时，只用把int换成char或者double
typedef struct SListNode
{
    SLTDateType data;
    struct SListNode* next;
}SLTNode;
//输出链表中的数据
void SListPrint(SLTNode* phead)
{
    SLTNode* cur=phead;//从第一个结点开始
    while(cur!=NULL)
    {
      printf("%d->",cur->data);//打印数据
      cur=cur->next;//指向下一个结点
    }
}
//尾插法
void SListPushBack(SLTNode** pphead,SLTDateType x)
{
    SLTNode* newnode=(SLTNode*)malloc(sizeof(SLTNode));
    newnode->data=x;
    newnode->next=NULL;//开辟一个数据的空间，把x放进去
    if(*pphead==NULL)
    {
       *pphead=newnode;//链表为空直接插入
    }
    else {
    SLTNode* tail=*pphead;
    while(tail->next!=NULL)
    {
        tail=tail->next;//从头结点开始找，一直找到尾结点
    }
        tail->next=newnode;//把数据插在尾结点的后面
    }
}
//头插法
void SListPushFront(SLTNode** pphead,SLTDateType x)
{
    SLTNode* newnode=(SLTNode*)malloc(sizeof(SLTNode));
    newnode->data=x;//开辟一个空间，存放X的值
    newnode->next=NULL;
    if(newnode==NULL)
    {
      printf("malloc fail\n");//打印数据
      exit(-1);//指向下一个结点
    }
    newnode->next=*pphead;//把x放在头结点的前面
    *pphead=newnode;//x此时的位置作为头结点
}
//尾删法
void SListpopBack(SLTNode** pphead)
{   
    assert(*pphead!=NULL);//不为空
    if((*pphead)->next==NULL)
    {
        free(*pphead);
        *pphead=NULL;//只有一个数据时，删除这个数据
    }
    SLTNode* pre=NULL;
    SLTNode* tail=*pphead;
    while(tail->next)
    {
    pre=tail;
    tail=tail->next;//从头结点开始，一直向后，到尾结点，pre是tail的前一个结点
    }
    free(tail);//释放tail空间
    tail=NULL;
    pre->next=NULL;
}
//头删法
void SListpopFront(SLTNode** pphead)
{
    assert(*pphead!=NULL);//不为空
    if((*pphead)->next==NULL)
    {
        free(*pphead);//只有一个数据时，释放这个数据
        *pphead=NULL;
    }
    else 
    {
    SLTNode* pre=*pphead;
    *pphead=(*pphead)->next;
    free(pre);    
    }
}
//找数据
SLTNode* SListFind(SLTNode* phead,SLTDateType x)
{
    SLTNode* cur=phead;
    while(cur)
    {
     if(cur->data==x)
     {
         return cur;//找到x的位置，返回
     }   
     else 
     {
         cur=cur->next;//找不到x，一直往下走
     }
    }
    return NULL;
}
//在pos位置前插入数据
void SListInsert(SLTNode** phead,SLTNode* pos,SLTDateType x)
{
    SLTNode* newnode=(SLTNode*)malloc(sizeof(SLTNode));
    newnode->data=x;
    newnode->next=NULL;//开辟一个数据的空间，把x放进去
    SLTNode* pre=*phead;
    while(pre->next!=pos)
    {
    pre=pre->next;//找到pos前一个位置
    }
    pre->next=newnode;
    newnode->next=pos;
}//复杂度O（N）
//在pos位置后插入数据
void SListInsertAfter(SLTNode* pos,SLTDateType x)
{
    SLTNode* newnode=(SLTNode*)malloc(sizeof(SLTNode));
    newnode->data=x;
    newnode->next=NULL;//开辟一个数据的空间，把x放进去
    newnode->next=pos->next;
    pos->next=newnode;   
}//复杂度O（1）
//删除结点
void SListErase(SLTNode** phead,SLTNode* pos)
{
    SLTNode* pre=*phead;
    if(*phead==pos)
    {    
    *phead=pos->next;//让链表第二个变成头
    free(pos);//释放掉第一个结点
    }
    else
    {
     while(pre->next!=pos)
     {
     pre=pre->next;     
     }
     pre->next=pos->next;//pos的上一个结点指向pos的下一个结点
     free(pos);
    }      
}
//删除该结点之后的结点
void SListEraseAfter(SLTNode** phead,SLTNode* pos)
{
    assert(pos->next);
    SLTNode* next=pos->next;
    pos->next=next->next;
    free(next);
}
//删除链表
void SListDestory(SLTNode** phead)
{
    assert(phead);
    SLTNode* cur=*phead;
    while(cur)
    {
    SLTNode* next=cur->next;//不到尾就一直删
    free(cur);
    cur=next;
    }
    *phead=NULL;
}
int main(void) 
{    
    return 0;
}

三、单链表部分例题

1.移除链表元素（力扣）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeElements(struct ListNode* head, int val){
         if(head==NULL)
     {
       return NULL;
   }
    struct ListNode* pre=NULL;
    struct ListNode*cur=head;
    
    while(cur)//cur不为空，一直往后走
    {
    if(cur->val==val)
    {  
      if(head->val==val)//如果头部等于val，头删
    {
    head=cur->next;//让链表第二个变成头
    free(cur);//释放掉第一个结点
    cur=head;//cur等于当前的头
    }  
    else
    {
    pre->next=cur->next;//头部数据不等于val，但找到了数据为val的位置,让pre的下一个指向cur的下一个结点值
    free(cur);//释放掉cur结点的值
    cur=pre->next; //让cur指向pre的下一个位置   
    }
    }
    else
    {
        pre=cur;//没有找到数据为val的位置
        cur=cur->next;//继续往后走
    }
    }
      return head;//返回新的头
}

2.反转链表（力扣）

①指针翻转

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head){
if(head==NULL)
{
  return NULL;
}
struct ListNode* n1,*n2,*n3;
n1=NULL;
n2=head;//n2一开始指向头结点
n3=head->next;//n3一开始指向第二个结点
while(n2)
{
    //翻转
    n2->next=n1;//第一个结点指向n1即空
    //迭代走
    n1=n2;//原来的第一个结点变为n1
    n2=n3;//原来的第二个结点变为n2
    if(n3)
    n3=n3->next;//n3变为原来n3的下一个
}
return n1;
}

② 头插（取原链表中结点，头插到newhead新链表中）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head){
struct ListNode* cur=head;
struct ListNode* newhead=NULL;
while(cur)
{
   struct ListNode* next=cur->next; 
   //头插
   cur->next=newhead;
   newhead=cur;
   cur=next;
}
return newhead;
}

3.找到链表的中间结点（力扣）

/**
*Definition for singly-linked list.
*struct ListNode{
    int val;
    struct ListNode *next;
*};
*/
//快慢指针，慢指针一次走一个结点，快指针一次走两个结点。当链表节点数为奇数时，快指针走完链表的时候，慢指针恰好走到中间；当为偶数时，快指针走到空时，慢指针走到中间
struct ListNode* middleNode(struct ListNode* head)
{
    struct ListNode* slow,*fast;
    slow=fast=head;
    while(fast&&fast->next)//当fast为空或者fast->next为空时结束
    {
    slow=slow->next;//slow一次走一个结点
    fast=fast->next->next;//fast一次走两个结点
    }
    return slow;
}

4.返回链表的倒数第k个结点（牛客）

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param head ListNode类 
 * @param n int整型 
 * @return ListNode类
 */
struct ListNode* removeNthFromEnd(struct ListNode* head, int k ) {
struct ListNode* fast,*slow;
slow=fast=head;
while(k--)//......k
//while(--k)......k-1
//fast先走k步，slow再走，当fast走到尾时，slow走到倒数第k个
{
    //k大于链表的长度,返回空
    if(fast==NULL)
    {
    return NULL;
    }
    fast=fast->next;//fast走k步
}
while(fast)
{
    fast=fast->next;
    slow=slow->next;//fast走到k之后fast和slow一起走，直到fast走到空
}
return slow;
}

 5.合并两个有序链表（力扣）

1.判断l1和l2是否为空；

2.定义头结点和尾结点；

3.判断l1和l2的大小，尾插；

4.判断是否第一次尾插；

5.判断l1和l2谁先结束；

6.返回头结点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
//其中一个链表为空，返回另外一个
if(l1==NULL)
{
    return l2;
}
if(l2==NULL)
{
    return l1;
}
struct ListNode* head=NULL,*tail=NULL;
while(l1&&l2)//只要有一个为空就停止
{
   if(l1->val<l2->val)
   {
       if(head==NULL)//第一次尾插
       {
           head=tail=l1;//把l1插到尾
       }
       else
       {
           tail->next=l1;//不是尾，插到尾
           tail=l1;//l1变为尾
       }
       l1=l1->next;//l1往后走
   }
   else
   {
       if(head==NULL)
       {
           head=tail=l2;
       }
       else
       {
           tail->next=l2;
           tail=l2;
       }
       l2=l2->next;//l2小，l2小往后走
   }
}
if(l1)
{
    tail->next=l1;//l2结束，把l1链接到tail后面
}
if(l2)
{
    tail->next=l2;//l1结束，把l2链接到tail后面
}
return head;
}

6.链表的分割（力扣）

                 （a）                            （b）

                    (c)                             (d)  

（a）（b）（c）（d）表示链表数据的整个存放过程，下面这个图则表示将两个链表合并起来，即将lessTail->next指向greatHead->next。

如果greatTail不指向空的话，就会出现如下所示的死循环 ，因此greatTail->next=NULL。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* partition(struct ListNode* head, int x){
struct ListNode* lessHead,*lessTail,* greatHead,*greatTail;
//开一个哨兵位头结点，方便尾插,先分为两个链表，less里存放比X小的值，great存放比X大的值
lessHead=lessTail=(struct ListNode*)malloc(sizeof(struct ListNode));
lessTail->next=NULL;
greatHead=greatTail=(struct ListNode*)malloc(sizeof(struct ListNode));
greatTail->next=NULL;
struct ListNode* cur=head;
while(cur)
{
   if(cur->val<x)
   {
      lessTail->next=cur;//值比X小，放在less里
      lessTail=cur;//cur变成队尾
   }
   else
   {
      greatTail->next=cur;//值比X大，放在great里
      greatTail=cur;//cur变成队尾
   }
   cur=cur->next;//指向下一个
}

   lessTail->next=greatHead->next;//合并两个链表
   greatTail->next=NULL;//防止出现死循环
   struct ListNode* newhead=lessHead->next;//保存头结点
   free(lessHead);
   free(greatHead);
   return newhead;
}

7.相交链表（牛客网）

判断两个链表是否相交；如果相交，求交点。

①暴力求解（穷举）：依次取A链表中的每个结点跟B链表中的所有结点比较，如果有地址相同的结点，就是相交，第一个相同的交点。

②要求优化到O（n）：尾结点相同就是相交，否则就不相交；长的链表先走（长度差步），再同时走，第一个相同就是交点。

 struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB)
 {
     struct ListNode* tailA=headA;
     struct ListNode* tailB=headB;
     int lenA=1;
     while(tailA->next)
     {   lenA++;//算出链表A的长度
         tailA=tailA->next;//找到A的尾
     } 
     int lenB=1;
     while(tailB->next)
     {
         lenB++;//算出链表B的长度
         tailB=tailB->next;//找到B的尾
     } 
     if(tailA!=tailB)//不相交
     {
         return NULL;
     }
     int gap=abs(lenA-lenB);
     //长的先走差距步，再同时走找交点
     struct ListNode* longList=headA;
     struct ListNode* shortList=headB;
     if(lenA<lenB)
     {
       shortList=headA;
       longList=headB;//如果B长，longList=headB;  
     }
     while(gap--)
     {
       longList=longList->next;   
     }
     while(longList!=shortList)
     {
       longList=longList->next;
       shortList=shortList->next; //没有相交的，两个链表就往后走
     }
     return longList;
 }

8.复制带随机指针的链表（力扣）

① 复制结点，插入到原结点和下一个结点之间；

② 根据原结点random，处理复制结点的random；

③ 复制结点解下来链接成一个新链表，恢复原链表链接关系。

struct Node* copyRandomList(struct Node* head) {
    //1.拷贝结点插入原结点的后面
    struct Node* cur=head;
    while(cur)
    {
       struct Node* copy=(struct Node*)malloc(sizeof(struct Node)); 
       copy->val=cur->val;//copy的值等于原结点的值
       //插入copy结点
       copy->next=cur->next;//第二个图
       cur->next=copy;
       cur=copy->next;//第三个图
    }
	//2.根据原结点，处理copy结点的random
    cur=head;
    while(cur)
    {
        struct Node* copy=cur->next;
        if(cur->random==NULL)
        {
            copy->random==NULL;
        }
        else
        {
            copy->random=cur->random->next;
        }
        cur=copy->next;
    }
    //3.把拷贝结点解下来，链接成新链表，同时恢复原链表。
    struct Node* copyHead=NULL,*copyTail=NULL;
    cur=head;
    while(cur)
    {
        struct Node* copy=cur->next;
        struct Node* next=copy->next;
        if(copyTail==NULL)
        {
            copyHead=copyTail=copy;//头插
        }
        else
        {
            copyTail->next=copy;//尾插
            copyTail=copy;//copyTail往后走
        }
        cur->next=next;//恢复原链表
        cur=next;
    }
    return copyHead;
}

我不要麦克风
关注
专栏目录
数据结构笔记：单链表
qq_17679843的博客
09-22 178
顺序表 一.顺序储存结构 与对数组的操作类似，并无太大新知识点，顾略去。 二.链式储存结构 单链表的储存不连续，每个储存单元既储存数据元素，又储存后继元素的地址。 因此，节点结构定义 template<typename T> struct Node { T data; Node<T> *next; }; 为了实现基本操作，创建模板 template<typena...
数据结构：单链表的基本操作
weixin_45213079的博客
08-17 1234
数据结构：单链表的基本操作
单链表笔记
Lzylijn的博客
07-10 201
单链表 代码定义 typedef struct LNode { ElemType data; //值域 struct LNode *next; //定义域 }LNode,*LinkList; ​ //等价于 struct LNode{ ElemType data; struct LNode *next; }; typedef struct LNode LNode; typedef struct LNode *LinkList; //要表示一个单...
数据结构学习笔记||单链表
weixin_44954209的博客
06-08 526
单链表 插入和删除结点的操作 1）插入结点 在单链表中插入一个新结点需要找到插入后的前驱结点 代码描述： s->next=p->next; p->next=s; 2）删除结点 需要找到其前驱结点 代码描述 p->next=p->next->next 一般情况下，删除结点后还需要释放其内存空间 q=p->next; //q临时保存被删结点 p->next=q->next; //从链表中删除结点q free(
数据结构之单链表操作合集.zip
最新发布
06-16
这个“数据结构之单链表操作合集.zip”文件显然是针对大学生学习数据结构而准备的资源，包含了丰富的学习材料。下面将详细讨论单链表的相关知识点。 单链表是一种线性数据结构，由一系列节点（也称为元素或记录）...
数据结构学习笔记——单链表
12-21
本文将深入探讨单链表这一常见数据结构，并与其他数据结构如数组进行对比。 单链表是一种线性数据结构，其特点是元素在内存中并非连续存储。每个节点由两部分构成：一个是存储数据的`data`变量，另一个是`next`指针...
数据结构学习笔记-单链表
02-16
在所有数据结构中，链表是一种基础且重要的类型，尤其是单链表。本学习笔记将聚焦于单链表的概念、操作以及在VS2022环境下如何实现。 单链表是一种线性数据结构，其元素（节点）不是在内存中连续存储的，而是通过...
【数据结构】单链表
Zxingyun12的博客
11-03 1915
数据结构与算法基础（青岛大学-王卓）笔记
数据结构-单链表（学习笔记）
YYYJ_BOY的博客
04-26 1503
一、单链表的结点数据类型 typedef int DataType; struct Node { DataTpye data; struct Node *next; //next为指向下一结点的指针 }; 二、初始化单链表 int InitList(Node *&H) { H = new Node; //分配空间，作为头结点 if(!H) { cout<<"...
【学习笔记】单链表（c语言）
Zero__two_的博客
10-03 635
1.单链表概念 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(s数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 2.链表分类 链表的结构多种多样有三个大分类： 1.单向、双向 2.带头、不带头 3.循环、不循环 而三组之间又可以互相组合，使得链表的结构多达8种，本篇的单链表主要是指单向不带头不循环链表，这也是本篇的重点。 2.1单向链表 单向
单链表初学笔记
fuhang95的博客
01-05 346
没什么好说的,添加头文件和创建单链表的形式 申明定义一个结构体,结构体类型名叫做 struct Node,为了便于理解,这个结构体里面的数据段只用来存储一个最简单的整形数据(data),然后定义一个(struct Node)类型的指针,用于指向后面一个链表元素的地址. 由于我们使用dypedef定义这个结构体类型为Nodelb,后面需要使用(struct Node)类型时就可以直接使用Nodelb #include <stdio.h> #include <stdlib.h> typ
学习笔记-单链表
touteng55的博客
02-07 220
单链表 单链表是由多个节点组成的。它是一种有序的链式存储，也就是在各节点的存储位置不一定相连。同时，单链表分为有头节点和没有头节点，具体通过工作的细节自己选择。而节点由数据和next指针组成。其中，next指针的作用是指向下一个节点。在java中，节点可以表示成一个类class，一些成员变量用来存储数据，比如name，sex等等，而next指针同样表示为一个成员变量，类型为该类。指向下一个类变量。 单链表的增删改查思路 创建单链表 首先需要创建节点类，类成员变量包括需要的数据属性和next指针。我这里创
单链表的C语言实现
Confession 的技术频道
01-23 415
一、单链表的建立 有了动态内存分配的基础，要实现链表就不难了。 所谓链表，就是用一组任意的存储单元存储线性表元素的一种数据结构。 链表又分为单链表、双向链表和循环链表等。我们先讲讲单链表。 所谓单链表，是指数据接点是单向排列的。一个单链表结点，其结构类型分为两部分： 1、数据域：用来存储本身数据 2、链域或称为指针域：用来存储下一个结点地址或者说指向其直接后继的指针。 例： typedef str
单链表 - 数据结构复习笔记
No1anWan6的博客
11-01 175
数据结构复习笔记-单链表 什么是单链表 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。 构成 链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 特点 链表是以节点的方式来储存数据的 每个节点包括data域，next指向下一个节点 在内存中各节点不一定连续存储 分为带头节点和不带头节点的链表 ...
单链表详解（学习笔记）
m0_61608863的博客
12-16 1363
链表是一种链式储存结构，在C语言中有着重要的作用。 而在如同我一样的初学者的学习过程中，链表的操作很有难度，故而有必要用博客记录学习过程，分享给大家的同时也自我巩固。 一.链表的概念和定义 相对于线性表，链表有许多优点，例如在线性表中，删除或插入元素的操作很复杂，需要将插入或删除位置的前/后元素不停地移动，倘若涉及到频繁地插入或者删除的操作，链表的优点就凸显出来了。 链表作为一种链式存储结构，其的存储内容除了要存的数据元素信息之外，还储存着后继元素的存储地址。为了表示链表中每一个存储元素a（i...
学习笔记-单链表操作
touteng55的博客
02-07 122
求单链表中有效节点的个数 /** * * @param head 链表的头节点 * @return 返回的就是有效节点的个数 */ public static int getLength(HeroNode head) { if(head.next == null) { //空链表 return 0; } int length = 0; //定义一个辅助的变量, 这里我们没有统计头节点 HeroNode cur = head.next; while(cur != null) { lengt
单链表
学习笔记
08-28 153
单链表 1、链表的创建 由于需要改变主函数头指针的值，所以将头指针的地址传给一个二级指针 int create_list(pnode *head) { if((*head = (pnode)malloc(sizeof(node))) == NULL) { return -1; //失败返回-1 } (*head)-&gt;data = -1; //-1表示头指针不存储内容 (...
大学生数据结构单链表操作学习资料大全
资源摘要信息:"数据结构之单链表操作合集.zip" 知识点一：单链表基础 单链表是一种常见的线性数据结构，它由一系列节点组成，每个节点包含数据域和指针域。数据域存储具体的数据元素，而指针域则存储指向下一个节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值