c语言实现单链表的基础操作

最新推荐文章于 2024-01-17 22:12:14 发布
最新推荐文章于 2024-01-17 22:12:14 发布
阅读量656 收藏 2
点赞数
分类专栏： 工欲善其事 文章标签： linux 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cyrus_wen/article/details/79676606
版权

接下来将介绍c语言实现单链表的一些基础操作：

 1. 初始化单链表
 2. 创建链表的节点
 3. 打印链表
 4. 销毁链表
 5. 尾部插入链表
 6. 尾部删除链表
 7. 头部插入元素
 8. 尾部插入元素
 9. 指定位置前插入元素
 10. 指定位置后插入元素
 11. 删除元素
 12. 删除指定元素
 13. 删除所有相同元素
 14. 判断链表是否为空
 15. 求链表长度

具体的实现代码如下:

头文件：linklist.h

#pragma once

//#include<stddef.h>

#define TestType printf("\n*************************%s*****************************\n",__FUNCTION__);

typedef char LinkNodeType;

typedef struct LinkNode{
    LinkNodeType data;
    struct LinkNode* next;
}LinkNode;


void LinkListInit(LinkNode** node);

LinkNode* CreateNode(LinkNodeType value);


void LinkListPrintChar(LinkNode* phead,const char* msg);

void LinkListDestroy(LinkNode** phead);

void LinkListPushBack(LinkNode** phead, LinkNodeType value);

void LinkListPopBack(LinkNode** phead);

void LinkListPushFront(LinkNode** phead,LinkNodeType value);

void LinkListPopFront(LinkNode** phead);

LinkNode* LinkListFind(LinkNode* phead,LinkNodeType to_find);

void LinkListInsert(LinkNode** phead,LinkNode* pos,LinkNodeType value);

void LinkListInsertAfter(LinkNode** phead,LinkNode* pos,LinkNodeType value);

void LinkListErase1(LinkNode** phead,LinkNode* pos);

void LinkListErase2(LinkNode** phead,LinkNode** pos);

void LinkListRemove(LinkNode** phead,LinkNodeType value);

void LinkListRemoveAll(LinkNode** phead,LinkNodeType value);

int LinkListEmpty(LinkNode* phead);

size_t LinkListSize(LinkNode* phead);

实现函数： linklist.c

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

//打印链表
void LinkListPrintChar(LinkNode* phead,const char* msg){
    printf("[%s]:\n",msg);
    LinkNode* cur = phead;
    for(;cur != NULL;cur = cur->next){
        printf("[%c][%p]->",cur->data,cur);
    }
    printf("[NULL]\n\n");

}

//初始化链表，将头指针指向空
void LinkListInit(LinkNode** node){
    if(node == NULL){
        //非法输入
        return;
    }
    *node = NULL;
}

//构造新的节点
LinkNode* CreateNode(LinkNodeType value){
    LinkNode* new_node = (LinkNode*)malloc(sizeof(LinkNode));
    if(new_node == NULL){
        printf("申请内存失败！\n");
        exit(1);
    }else{
        new_node->data = value;
        new_node->next = NULL;
        return new_node;
    }
}

//释放节点
void DestroyNode(LinkNode* node){
    free(node);
}

//销毁链表
void LinkListDestroy(LinkNode** phead){
    if(phead == NULL){
        return;
    }
    if(*phead == NULL){
        return;
    }
    //遍历整个链表，从头开始删除
    while((*phead)->next != NULL){
        LinkNode* pnode = *phead;
        *phead = (*phead)->next;
        free(pnode);
        pnode = NULL;
    }
    return;
}

//尾部插入元素
void LinkListPushBack(LinkNode** phead, LinkNodeType value){

    if( phead == NULL){
        //非法输入
        return;
    }

    if(*phead == NULL){
        //空链表，指向结构体的指针都不存在，说明结构体不存在
        *phead = CreateNode(value);
        return;
    }
    LinkNode* cur = *phead;
    while(cur->next != NULL){
        cur = cur->next;
    }
    //找到最后一个节点的指针
    cur->next = CreateNode(value);
    return;
}

//尾部删除
void LinkListPopBack(LinkNode** phead){

    if(phead == NULL){
        return;
    }

    if(*phead == NULL){
        printf("链表为空，无法删除.\n");
        return;
    }

    if((*phead)->next == NULL){
        DestroyNode(*phead);
        *phead = NULL;
        return;
    }

    LinkNode* cur = *phead;
    while(cur->next->next != NULL){
        cur = cur->next;
    }
    LinkNode* last = cur->next;
    DestroyNode(last);
    cur->next = NULL;
    return;
}

//头部插入节点
void LinkListPushFront(LinkNode** phead,LinkNodeType value){
    if(phead == NULL){
        return;
    }
    if(*phead == NULL){
        *phead = CreateNode(value);
        return;
    }
    LinkNode* cur = *phead;
    *phead = CreateNode(value);
    (*phead)->next = cur;
    return;
}

//头部删除节点
void LinkListPopFront(LinkNode** phead){
    if(phead == NULL){
        return;
    }
    if(*phead == NULL){
        printf("链表为空，无法删除.\n");
        return;
    }
    LinkNode* cur = (*phead)->next;
    (*phead)->next = NULL;
    DestroyNode(*phead);
    *phead = cur;
    return;
}

//查找节点
LinkNode* LinkListFind(LinkNode* phead,LinkNodeType to_find){
    if(phead == NULL){
        printf("链表为空，查找不到！\n");
        return;
    }
    LinkNode* cur = phead;
    for(;cur != NULL; cur = cur->next){
        if(cur->data == to_find){
            return cur;
        }
    }
    return;
}

//指定位置前插入节点
void LinkListInsert(LinkNode** phead,LinkNode* pos,LinkNodeType value){
    if(phead == NULL){
        return;
    }
    if(*phead == NULL){
        //若为空链表，pos位置无效，将value当作新节点插入
        *phead = CreateNode(value);
        return;
    }
    if(pos == NULL){
        //pos为NULL,简化为尾插
        LinkListPushBack(phead,value);
        return;
    }
    if(pos == *phead){
        //pos为头节点，简化为头插
        LinkListPushFront(phead,value);
        return;
    }
    LinkNode* cur = *phead;
    while(cur->next != NULL){
        if(cur->next == pos){
            LinkNode* tmp = CreateNode(value);
            tmp->next = pos;
            cur->next = tmp;
            return;
        }
        cur = cur->next;
    }
    printf("没有找到！\n");
    return;
}

//指定位置后插入节点
void LinkListInsertAfter(LinkNode** phead,LinkNode* pos,LinkNodeType value){
    if(phead == NULL){
        return;
    }
    if(*phead == NULL){
        //链表为空，则直接将value作为新节点插入
        *phead = CreateNode(value);
        return;
    }
    if(pos == NULL){
        printf("[ pos = NULL ]\n");
        printf("非法输入!\n\n");
        return;
    }
    LinkNode* cur = *phead;
    while(cur->next != NULL){
        if(cur == pos){
            LinkNode* tmp = CreateNode(value);
            tmp->next = cur->next;
            cur->next = tmp;
            return;
        }
        cur = cur->next;
    }
    return;
}

void LinkListErase1(LinkNode** phead,LinkNode* pos){
    //找到前一个元素进行删除的方法
    if(phead == NULL || pos == NULL){
        //非法输入
        return;
    }
    if(*phead == NULL){
        printf("[ phead = NULL ]\n");
        printf("空链表，无法删除！\n\n");
        return;
    }
    if(*phead == pos){
        //删除位置是头节点
        LinkNode* to_delete = *phead;
        *phead = (*phead)->next;
        DestroyNode(to_delete);
        to_delete->next = NULL;
        return;
    }

    //找到前一个节点进行删除
    LinkNode* cur = *phead;
    while(cur != NULL){
        if(cur->next == pos){
            cur->next = pos->next;
            DestroyNode(pos);
            pos->next = NULL;
            return;
        }
        cur = cur->next;
    }
    return;
}

//移形换位法，用要删除节点的后一个节点覆盖前一个节点，删除后面的节点
//优点：不用遍历整合链表
void LinkListErase2(LinkNode** phead,LinkNode** pos){
    if(phead == NULL){
        return;
    }
    if(*phead == NULL){
        printf("[ phead = NULL ]\n");
        printf("链表为空，无法删除！\n\n");
        return;
    }
    if(*pos != NULL && (*pos)->next != NULL){
        LinkNode* to_delete = (*pos)->next;
        (*pos)->data = to_delete->data;
        (*pos)->next = to_delete->next;
        to_delete->next = NULL;
        DestroyNode(to_delete);
        return;
    }
    if((*pos)->next == NULL){
        LinkListPopBack(phead);
        return;
    }
    printf(" 找不到pos，无法删除！\n");
    return;
}

//删除指定的节点
void LinkListRemove(LinkNode** phead,LinkNodeType value){
    if(phead == NULL){
        return;
    }
    if(*phead == NULL){
        return;
    }
    LinkNode* pos = LinkListFind(*phead,value);
    LinkListErase1(phead,pos);
}

//删除链表中所有指定的元素
void LinkListRemoveAll(LinkNode** phead,LinkNodeType value){
    if(phead == NULL){
        return;
    }
    if(*phead == NULL){
        return;
    }
    while(1){
        LinkNode* to_delete = LinkListFind(*phead,value);
        if(to_delete == NULL){
            break;
        }
        LinkListErase1(phead,to_delete);
    }
    return;
}

//判断链表是否为空，为空返回1 不为空返回0
int LinkListEmpty(LinkNode* phead){

    return phead == NULL ? 1 : 0;

}

//求链表的长度
size_t LinkListSize(LinkNode* phead){
    size_t  count = 1;
    if(phead == NULL){
        return 0;
    }
    LinkNode* cur = phead;
    for(;cur->next != NULL;cur = cur->next){
        count++;
    }
    return count;
}

测试函数：main.c

#include"linklist.h"
#include<stdio.h>

void TestInit(){
    TestType;
    LinkNode* phead;
    LinkListInit(&phead);
    printf("phead = %p\n",phead);
}


void TestPushBack(){
    TestType;
    LinkNode* phead;
    LinkListInit(&phead);
    LinkListPushBack(&phead,'a');
    LinkListPushBack(&phead,'b');
    LinkListPushBack(&phead,'c');
    LinkListPushBack(&phead,'d');
    LinkListPrintChar(phead," 尾部插入");
    LinkListPopBack(&phead);
    LinkListPrintChar(phead," 尾部删除 ");
}

void TestLinkListPushFront(){
    TestType;
    LinkNode* phead;
    LinkListInit(&phead);
    LinkListPushBack(&phead,'a');
    LinkListPushBack(&phead,'b');
    LinkListPushBack(&phead,'c');
    LinkListPushBack(&phead,'d');
    LinkListPrintChar(phead," 尾部插入 ");
    LinkListPushFront(&phead,'x');
    LinkListPrintChar(phead," 头部插入 ");
    LinkListPopFront(&phead);
    LinkListPrintChar(phead," 头部删除 ");
}

void TestLinkListFind(){
    TestType;
    LinkNode* phead;
    LinkNode* cur;
    LinkListInit(&phead);
    LinkListPushBack(&phead,'a');
    LinkListPushBack(&phead,'b');
    LinkListPushBack(&phead,'c');
    LinkListPushBack(&phead,'d');
    LinkListPushBack(&phead,'e');
    LinkListPrintChar(phead," 插入五个元素 ");
    cur = LinkListFind(phead,'d');
    printf("要查找的元素位于[%p]\n",cur);
}

void TestLinkListInsert(){
    TestType;
    LinkNode* phead;
    LinkListInit(&phead);
    LinkListInsert(&phead,phead,'x');
    LinkListPrintChar(phead," 对空链表插入 ");
    LinkListPushBack(&phead,'a');
    LinkListPushBack(&phead,'b');
    LinkListPushBack(&phead,'c');
    LinkListPushBack(&phead,'d');
    LinkListPushBack(&phead,'e');
    LinkListPrintChar(phead," 尾部插入五个元素 ");
    LinkListInsert(&phead,NULL,'y');
    LinkListPrintChar(phead," pos = NULL ");
    LinkListInsert(&phead,phead,'z');
    LinkListPrintChar(phead," pos = phead ");
    LinkNode* pos = LinkListFind(phead,'c');
    LinkListInsert(&phead,pos,'m');
    LinkListPrintChar(phead," c位置插入m ");
}

void TestLinkListInsertAfter(){
    TestType;
    LinkNode* phead;
    LinkListInit(&phead);
    LinkListInsertAfter(&phead,phead,'x');
    LinkListPrintChar(phead," 对空链表插入 ");
    LinkListPushBack(&phead,'a');
    LinkListPushBack(&phead,'b');
    LinkListPushBack(&phead,'c');
    LinkListPushBack(&phead,'d');
    LinkListPushBack(&phead,'e');
    LinkListPrintChar(phead," 尾部插入五个元素 ");
    LinkListInsertAfter(&phead,NULL,'y');
    LinkListInsertAfter(&phead,phead,'z');
    LinkListPrintChar(phead," pos = phead ");
    LinkNode* pos = LinkListFind(phead,'c');
    LinkListInsertAfter(&phead,pos,'m');
    LinkListPrintChar(phead," c位置插入m ");
}

TestLinkListErase1(){
    TestType;
    LinkNode* phead;
    LinkListInit(&phead);
    LinkListPushBack(&phead,'a');
    LinkListPushBack(&phead,'b');
    LinkListPushBack(&phead,'c');
    LinkListPushBack(&phead,'d');
    LinkNode* pos = LinkListFind(phead,'d');
    LinkListErase1(&phead,phead);
    LinkListPrintChar(phead," 删除头节点 ");
    LinkListErase1(&phead,pos);
    LinkListPrintChar(phead," 删除d元素 ");
}

TestLinkListErase2(){
    TestType;
    LinkNode* phead;
    LinkListInit(&phead);
    LinkListPushBack(&phead,'a');
    LinkListPushBack(&phead,'b');
    LinkListPushBack(&phead,'c');
    LinkListPushBack(&phead,'d');
    LinkListPrintChar(phead," 尾插四个元素 ");
    LinkNode* posa = LinkListFind(phead,'a');
    LinkNode* posd = LinkListFind(phead,'d');
    LinkListErase2(&phead,&posa);
    LinkListPrintChar(phead," 删除a元素 ");
    LinkListErase2(&phead,&posd);
    LinkListPrintChar(phead," 删除d元素 ");
}

TestLinkListRemove(){
    TestType;
    LinkNode* phead;
    int empty;
    int count;
    LinkListInit(&phead);
    LinkListPushBack(&phead,'a');
    LinkListPushBack(&phead,'b');
    LinkListPushBack(&phead,'c');
    LinkListPushBack(&phead,'d');
    LinkListPrintChar(phead," 尾插四个元素 ");
    empty = LinkListEmpty(phead);
    printf("empty = [%d]\n",empty);
    count = LinkListSize(phead);
    printf("数组长度为：%d\n\n",count);
    LinkListRemove(&phead,'c');
    LinkListPrintChar(phead," 删除元素c ");
}

TestLinkListRemoveAll(){
    TestType;
    LinkNode* phead;
    LinkListInit(&phead);
    LinkListPushBack(&phead,'b');
    LinkListPushBack(&phead,'a');
    LinkListPushBack(&phead,'c');
    LinkListPushBack(&phead,'b');
    LinkListPushBack(&phead,'a');
    LinkListPushBack(&phead,'b');
    LinkListPushBack(&phead,'c');
    LinkListPushBack(&phead,'b');
    LinkListPrintChar(phead," 尾部插入元素 ");
    LinkListRemoveAll(&phead,'b');
    LinkListPrintChar(phead," 删除所有的b ");
}

int main(){
    TestInit();
    TestPushBack();
    TestLinkListPushFront();
    TestLinkListFind();
    TestLinkListInsert();
    TestLinkListInsertAfter();
    TestLinkListErase1();
    TestLinkListErase2();
    TestLinkListRemove();
    TestLinkListRemoveAll();
    return 0;
}

Makefile

linklist:linklist.c main.c
    gcc $^ -o -g $@
.PHONY:clean
clean:
    rm linklist

这是单链表的一些基本操作，在写单链表函数的时候最好在纸上画一下链表，只要理清增删改查得思路，代码自然而然的就能写出来，还有一些其它的操作，我将在之后的博客中介绍。

由于个人能力有限，以上的说明可能有Bug或者有什么不妥之处，欢迎发邮件到我的邮箱（ Cyrus_wen@163.com ）批评指正！

Cyrus_wen
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言实现单链表基本操作
Yz529的博客
05-28 210
单链表基本的操作有增删改查： 基本操作代码如下： 初始化： typedef struct list_node { int data; struct list_node *next; } LinkList; //初始化单链表L为空--头结点,即创建头结点 LinkList *ListInit(LinkList *L) { L = (LinkList *)malloc(sizeof(LinkList)); if (!L) { exit(-1);
数据结构 C语言 实现单链表的各种基本操作
WindsProgrammer的博客
06-01 5516
大概写了150多行，都是很基础的操作。需要的自取。 （书籍为数据结构教程（第五版）李春葆） 实验内容 实验三 链表基本操作的实现 【实验目的】 1．掌握线性表的链式存储表示。 2．掌握单链表的基本操作，包括创建、查找、插入和删除等算法。 【实验内容】 编写程序linklist.cpp，实现单链表的各种基本运算（假设单链表的元素类型为char），并在此基础上设计主程序main.cpp，完成如下功能： 1．初始化单链表； 2．依次采用尾插法插入元素a，b，c，d，e； 3．输出单链表； 4．判断单链表的长度；
【数据结构】二、单链表的基本操作(C语言)
lieam的博客
12-22 7689
【数据结构】二、单链表的基本操作(C语言)
单链表基本操作（保姆级教程）c语言
m0_53553327的博客
08-08 1954
单链表定义： 1、表中的数据是以结点来表示的，每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 2、链表的结点结构 ┌───┬───┐ │data│next│ └───┴───┘ data域–存放结点值的数据域 next域–存放结点的直接后继的地址(位置)的指针域(链域)。 单链表的基本操作： 1.头文件 数据类型准备 2.单链表的初始化 3.单链表的显示 4.单链表的头插法 5.单链表的插入方法 6.单链表的删除 7.单
C语言数据结构-链表的基本操作（超详细）
2301_79975618的博客
01-17 1018
目录：1.单链表的分类；2.单链表的操作；3.代码详解；4.完整代码展示；一：单链表的分类总体上来说，单链表可以分为两大类，一种是带头结点的，另一种是不带头结点的（如果分细来讲，链表的插入可以分为两种：头插法和尾插法。二：单链表的操作1.单链表的初始化；2.单链表的头插法；3.单链表的尾插法；4.删除元素；5.遍历链表；
【数据结构】单链表的基本操作（C语言版）
2301_76606232的博客
12-25 1181
单链表（Singly linked list）是一种常见的数据结构，它由一个结点（Node）的链表构成，每个结点包含两个域：数据域和指针域。数据域用于存储结点的数据，指针域用于存储下一个结点的地址。单链表中的第一个结点被称为头结点（Head），它用来存放链表的基地址。头结点中的指针域指向链表的第一个结点，最后一个结点的指针域指向空地址，表示链表结束。// 数据域，存储结点的数据// 指针域，指向下一个结点}ListNode;
实现单链表的基本操作（c语言）
qq_63152286的博客
02-18 5234
链表介绍 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 一、实现单链表的具体操作 定义链表元素 创建单链表：①头插法 ②尾插法 按位序插入结点 按位序删除结点 按位查找结点 销毁顺序表 打印链表
C语言实现单链表的操作
07-27
C语言实现单链表的所有基本操作，500行左右，键盘输入
用C语言实现单链表的各种操作(二)
01-20
用C语言实现单链表的各种操作(一)>主要是单链表的一些最基本的操作，下面，主要是一些其他的典型的算法和测试程序。 代码如下:/* 对单链表进行排序处理*/struct LNode *sort(struct LNode *head){ LinkList *p; ...
用C语言实现单链表的各种操作(一)
09-05
本文将详细介绍如何用C语言实现单链表的各种操作。 首先，我们定义链表的结构体`LNode`，它包括一个数据域`ElemType data`和一个指向下一个节点的指针`struct LNode *next`： ```c typedef struct LNode{ ...
单向链表的C语言实现
11-07
C语言指针实现单向链表 初学者看，非常简单。 时间非常多的功能不同位置的插入、删除、查找；
基于C语言实现单链表的基本操作
最新发布
03-25
以上就是使用C语言实现单链表的基本操作。通过这些函数，我们可以对链表进行各种常见的操作，例如创建、插入、删除、查找、打印、计算长度以及反转。在实际应用中，可以根据具体需求扩展这些功能，比如合并两个已...
c语言实现单链表算法示例分享
09-04
"c语言实现单链表算法示例分享" 单链表是一种基础的数据结构，在计算机科学中广泛应用。下面将详细介绍c语言实现单链表算法的示例。 1. 单链表的定义 单链表是一种链式数据结构，其中每个节点由数据域和指针域...
单链表的基本操作c语言实现
gongdileidechouzhu的博客
02-25 1万+
#include<stdio.h> #define false 0 #define ok 1//定义节点的结构 typedef struct node{ int data; struct node *next; }node; typedef struct node *linklist;//初始化链表，创建一个链表并赋值 void creatlist(linklist *l,int n
【C语言】链表及单链表基本操作
热门推荐
swag_wg的博客
04-29 12万+
1、什么是链表？链表的分类？ 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 数据结构中： 2、链表的分类 共有8种链表结构 ...
用c语言实现单链表的基本操作
用c语言实现单链表的基本操作
10-19 2970
** ** ***备注：***自己刚学习数据结构，用来记录自己的学习之旅途，用于复习，一开始学的时候很是不能理解，但 现在有了一定的理解，在此代码中一定要理解各个模块的核心操作 以及注意在打印中的一个小问题。 所学习书籍为《数据结构–用c语言描述》（第2版） //单链表的操作 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef...
LeetCode-707-设计链表-C语言
SFFS
05-08 414
typedef struct ListNode Node; typedef struct { /* 一个虚拟的节点，node.next才是链表的头节点 */ Node node; /* 用于记录链表的尾节点 */ Node *rear; /* 用于记录链表的长度，根据长度判断，检索插入等操作是否合法 */ int len; } ...
C语言对链表的基本操作（头插法，尾插法，增加节点，删除节点，链表遍历）
北风
11-07 3225
我个人在对C语言的学习中感觉对链表的操作开始是很难理解的，因为一开始是自学，链表这一节是直接跳过了，后来学习数据结构发现链表就是数据结构的基本操作，如果链表不会用C语言代码写出来，数据结构就只能直接手写伪代码，这样也不知道直接的算法是否正确，所以建议初学的时候最好克服困难把链表好好看看，以下是我的一些学习链表基本操作的方法。 1. 链表的结构体定义（结点定义） 链表的一个结点首先肯定包含一个数...
linux下消息队列的查看与删除（ipcs&ipcrm的使用）
Cyrus_wen的博客
04-08 2万+
ipcs ipcs -q : 显示所有的消息队列 ipcs -qt : 显示消息队列的创建时间，发送和接收最后一条消息的时间 ipcs -qp: 显示往消息队列中放消息和从消息队列中取消息的进程ID ipcs -q -i msgid: 显示该消息队列结构体中的消息信息： ipcs -ql : 显示消息队列的限制信息： 取得ipc信息： ipcs [-m|-q|-s] -m 输出有关...
c语言实现单链表基本操作
08-15
下面是C语言实现单链表的基本操作的示例代码： ```c #include #include // 定义链表节点结构 struct Node { int data; struct Node* next; }; // 创建新节点 struct Node* createNode(int data) { struct ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值