【数据结构】—C语言实现双向链表（超详细!）

最新推荐文章于 2024-04-23 02:05:17 发布
最新推荐文章于 2024-04-23 02:05:17 发布
阅读量2.8k 收藏 37
点赞数 21
分类专栏： 数据结构与算法炼体 淬体中 文章标签： 数据结构 c++ c语言 链表 学习 经验分享 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64038246/article/details/132091011
版权

                                     食用指南：本文在有C基础的情况下食用更佳 

                                    🔥这就不得不推荐此专栏了：C语言

                                    🍀双向链表前置知识：单链表 

                                    ♈️今日夜电波：Departures ~あなたにおくるアイの歌~ —EGOIST 

                                                                    3:12 ━━━━━━️💟──────── 4:13                                                                                                                             🔄   ◀️   ⏸   ▶️    ☰

                                   💗关注👍点赞🙌收藏您的每一次鼓励都是对我莫大的支持😍 

一、双向链表介绍

什么是双向链表？

        它是是一种常见的线性数据结构，它由一系列节点组成，每个节点包含两个指针，一个指向前一个节点（pre指针），一个指向后一个节点（next指针）。

双向链表的基本结构？

        一张图让你明白：

        注：此为带哨兵的双向链表

         注：next表示为指向下一个节点的指针，prev表示为指向上一个节点的指针，而head则是作为标兵的存在，里面不存数据，其他data存数据，此双向链表无指向NULL的指针，读者可在下文初始化双向链表得到疑惑的答案。

与单链表相比的优势？

  1. 双向遍历：由于每个节点都存储了前向和后向指针，可以从头到尾或者从尾到头方便地遍历链表。这样的遍历方式在某些场景下非常有用，特别是需要反向操作或者双向查找的情况。

  2. 方便插入和删除：在双向链表中，插入和删除操作相对容易。通过修改前后指针，可以方便地调整节点的连接关系，无需像单链表那样需要在删除节点时找到其前驱节点。

  3. 更灵活的操作：双向链表相比单链表，对于节点的操作更加灵活。例如，在单链表中，如果要删除某个节点，需要先找到它的前驱节点，而在双向链表中，可以直接通过节点本身进行删除操作。

  4. 提高性能：在某些情况下，双向链表可以提高性能。例如，在需要频繁从链表中删除节点或者在给定节点后插入新节点的情况下，双向链表可以更高效地完成这些操作。

        总的来说，双向链表在一些特定场景下相比单链表具有更多的优势和灵活性，双向链表是单链表的优化！

二、总体思路

如何实现？

        参照🍀双向链表前置知识：单链表 （这是个链接，快点！），我们同样需要实现增、删、查、改。同样的我们需要先定义好节点，以此得到基本的结构->接着定义好接口（定义完后发现比单链表简单多了）->最后按照接口实现每一个功能 。

        节点的定义（结构体）

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;
	struct ListNode* _next;
	struct ListNode* _prev;
}ListNode;

        接口的定义 

// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

三、具体每个接口函数的实现

        1、初始化（重点）

ListNode* ListCreate()
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (!node)
	{
		perror("malloc fail:");
		exit(-1);
	}

	node->_next = node;
	node->_prev = node;

	return node;
}

        可以看到初始化的作用是建立了一个标兵，这个标兵没有被赋值，因为他的值是多少无关紧要，重点在于：他的next指针指向的是他自己，而prev指针指向的也是他自己。这说明了什么？这说明了双向链表的最开始就是在没有任何值的时候就只有一个标兵，也就是说双向链表的每一个指针都不是空的，都是有指向的，他们指向的地址不可能为NULL。

        2、销毁链表

void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->_next;
	while (cur != pHead)
	{
		ListNode* tmp = cur->_next;
		free(cur);
		cur = tmp;
	}

	free(pHead);
}

        3、查找功能（返回pos的地址）

ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	ListNode* cur = pHead->_next;
	while (cur != pHead)
	{
		if (cur->_data == x)
			return cur;
		cur = cur->_next;
	}

	return NULL;

}

        4、插入节点的实现（基于查找功能）

ListNode* BuyNode(LTDataType x)//实现节点的获取
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->_data = x;
	node->_next = NULL;
	node->_prev = NULL;

	return node;
}

void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);

	ListNode* newnode = BuyNode(x);
	ListNode* dist = pos->_prev;

	dist->_next = newnode;
	newnode->_prev = dist;
	newnode->_next = pos;
	pos->_prev = newnode;
	
}

     特别注意

          注意：在实现了 插入的功能后，其实一切都简单了起来，比如头插等等，只需要几行代码就能完成操作，而下面的删除操作的实现对于头删等等都是仅需要几行代码就能实现，因此，我们如果要快速的写完一个单链表或者其他链表，最好是从插入和删除开始写！o.o

        5、删除节点（基于查找功能）

void ListErase(ListNode* pos)
{
	assert(pos);

	ListNode* posPrev = pos->_prev;
	ListNode* posNext = pos->_next;

	posPrev->_next = posNext;
	posNext->_prev = posPrev;
	free(pos);
}

        6、尾插

void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	//ListInsert(pHead, x);//此为简化，如要简化代码，此段带码后的代码可都不要

	ListNode* newnode = BuyNode(x);

	pHead->_prev->_next = newnode;
	newnode->_prev=pHead->_prev;
	newnode->_next = pHead;
	pHead->_prev = newnode;
}

        7、尾删

void ListPopBack(ListNode* pHead)
{
	assert(pHead);
	//ListErase(pHead->_prev);//此为简化，如要简化代码，此段带码后的代码可都不要

	if (pHead->_prev != pHead)
	{
		ListNode* tmp = pHead->_prev;
		pHead->_prev = tmp->_prev;
		tmp->_prev->_next = pHead;
		free(tmp);
		tmp = NULL;
	}
}

        8、头插

void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	//ListInsert(pHead->_next, x);//此为简化，如要简化代码，此段带码后的代码可都不要

	ListNode* newnode = BuyNode(x);
	newnode->_next=pHead->_next;
	newnode->_prev = pHead;
	pHead->_next->_prev = newnode;
	pHead->_next = newnode;
}

        9、头删

void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	//ListErase(pHead->_next);//此为简化，如要简化代码，此段带码后的代码可都不要

	if (pHead->_next != pHead)
	{
		ListNode* node = pHead->_next;
		node->_next->_prev = pHead;
		pHead->_next = node->_next;
		free(node);
		node = NULL;
	}
}

        10、打印

void ListPrint(ListNode* pHead)
{
	ListNode* cur = pHead->_next;
	printf("pHead<=>");
	while (cur != pHead)
	{
		printf("%d<=>", cur->_data);
		cur = cur->_next;
	}
	printf("\n");
}

四、总体代码

1、头文件

#pragma once
#define _CRT_SECURE_NO_WARNINGS 01
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;
	struct ListNode* _next;
	struct ListNode* _prev;
}ListNode;

// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

2、主体函数文件

#include"list.h"

ListNode* BuyNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->_data = x;
	node->_next = NULL;
	node->_prev = NULL;

	return node;
}

ListNode* ListCreate()
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (!node)
	{
		perror("malloc fail:");
		exit(-1);
	}

	node->_next = node;
	node->_prev = node;

	return node;
}

void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->_next;
	while (cur != pHead)
	{
		ListNode* tmp = cur->_next;
		free(cur);
		cur = tmp;
	}

	free(pHead);
}

void ListPrint(ListNode* pHead)
{
	ListNode* cur = pHead->_next;
	printf("pHead<=>");
	while (cur != pHead)
	{
		printf("%d<=>", cur->_data);
		cur = cur->_next;
	}
	printf("\n");
}

void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	//ListInsert(pHead, x);
	ListNode* newnode = BuyNode(x);

	pHead->_prev->_next = newnode;
	newnode->_prev=pHead->_prev;
	newnode->_next = pHead;
	pHead->_prev = newnode;
}

void ListPopBack(ListNode* pHead)
{
	assert(pHead);
	//ListErase(pHead->_prev);
	if (pHead->_prev != pHead)
	{
		ListNode* tmp = pHead->_prev;
		pHead->_prev = tmp->_prev;
		tmp->_prev->_next = pHead;
		free(tmp);
		tmp = NULL;
	}
}

void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	//ListInsert(pHead->_next, x);
	ListNode* newnode = BuyNode(x);
	newnode->_next=pHead->_next;
	newnode->_prev = pHead;
	pHead->_next->_prev = newnode;
	pHead->_next = newnode;
}

void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	//ListErase(pHead->_next);
	if (pHead->_next != pHead)
	{
		ListNode* node = pHead->_next;
		node->_next->_prev = pHead;
		pHead->_next = node->_next;
		free(node);
		node = NULL;
	}
}

ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	ListNode* cur = pHead->_next;
	while (cur != pHead)
	{
		if (cur->_data == x)
			return cur;
		cur = cur->_next;
	}

	return NULL;

}

void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);

	ListNode* newnode = BuyNode(x);
	ListNode* dist = pos->_prev;

	dist->_next = newnode;
	newnode->_prev = dist;
	newnode->_next = pos;
	pos->_prev = newnode;
	
}

void ListErase(ListNode* pos)
{
	assert(pos);

	ListNode* posPrev = pos->_prev;
	ListNode* posNext = pos->_next;

	posPrev->_next = posNext;
	posNext->_prev = posPrev;
	free(pos);
}

3、测试用例

#include"list.h"


void text()
{
	ListNode* phead = ListCreate();
	ListPushBack(phead, 1);
	ListPushBack(phead, 2);
	ListPushBack(phead, 3);
	ListPrint(phead);

	ListPopBack(phead);
	ListPrint(phead);
	
	ListPushFront(phead, 10);
	ListPushFront(phead, 20);
	ListPushFront(phead, 30);
	ListPrint(phead);

	ListPopFront(phead);
	ListPrint(phead);

	ListNode* pos = ListFind(phead, 20);
	if (pos)
	{
		ListInsert(pos, 300);
	}
	ListPrint(phead);

	ListErase(pos);
	ListPrint(phead);

	ListDestory(phead);
}

int main()
{
	text();
	return 0;
}

        测试结果：

                    感谢你耐心的看到这里ღ( ´･ᴗ･` )比心，如有哪里有错误请踢一脚作者o(╥﹏╥)o！ 

                                ​​​​​​​       

                                                                         给个三连再走嘛~  

慕斯( ˘▽˘)っ
关注
  • 21
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 19
    评论
专栏目录
循环双向链表（C语言）
09-17
循环双向链表，实现了插入、查找特定的节点、删除等功能，是自己花了半天的时间写完的。
双向链表API及C语言实现
03-29
双向链表的API和C语言实现，程序说明在我的专栏《数据结构与算法学习笔记》中双向链表相关文章。包含了双向链表的结点结构体、表头结构体、创建双向链表、销毁双向链表、获取链表长度、清空双向链表、插入一个节点元素（包含异常分析）、按位置删除链表结点（包含异常分析）、按元素删除链表结点、返回一个结点元素、重置游标、游标上移、游标下移以及测试函数。所有API实现均为C语言版本，在我的文章《【数据结构】双向链表的API及C语言实现》中有所有API说明和异常分析的图解。另外还有线性表顺序存储、单链表、循环链表的C语言实现，文章及代码资源均已上传，可在专栏《数据结构与算法学习笔记》中查看，欢迎大家查看下载，如果内容有不合理的地方，欢迎大家批评指正。
双向链表--C语言实现数据结构
2201_76062618的博客
05-13 4583
本文详细介绍带头双向循环链表，内容较为丰富
C语言数据结构之线性表-双向链表篇
2301_79201049的博客
01-26 928
注意：这里的 带头 跟前⾯我们说的 头节点 是两个概念，实际前面的在单链表阶段称呼不严 谨，但是为了大家更好的理解就直接称为单链表的头节点
C语言双向链表的表示与实现实例详解
09-04
主要介绍了C语言双向链表的表示与实现，对于研究数据结构域算法的朋友有一定的参考借鉴价值,需要的朋友可以参考下
C语言数据结构 双向链表的建立与基本操作
01-01
C语言数据结构 双向链表的建立与基本操作 双向链表比单链表有更好的灵活性，其大部分操作与线性表相同。下面总结双向链表与单链表之间的不同之处及我在实现过程中所遇到的问题。 1.双向链表的建立 双向链表在初始化时，要给首尾两个节点分配内存空间。成功分配后，要将首节点的prior指针和尾节点的next指针指向NULL，这是十分关键的一步，因为这是之后用来判断空表的条件。同时，当链表为空时，要将首节点的next指向尾节点，尾节点的prior指向首节点。 2.双向链表的插入操作 由于定义双向链表时指针域中多了一个prior指针，插入操作相应变得复杂，但基本操作也并不难理解。只需记住在处理前驱和后
C语言---双向链表（详解）---数据结构
weixin_57535054的博客
02-07 6430
双向链表所需要头文件 首先重定义类型名 意义我前几篇讲过几次了，这里就不在赘述了，（顺序表，单链表的开头都有说明） 然后我们需要一个结构体 结构体包含 ： 存储数据的 a 指向一个节点的指针 next 指向上一个节点的指针 prve 双向链表实现的函数功能有 ：1.申请动态内存空间 2.初始化 3.双向链表的头，尾的插入与删除，在合法的任意位置进行插入和删除 4.释放链表，5.打印链表 1.申请动态内存空间 因为进行插入和初始化需要用到此函数 所以我们要先实现此功能 1.先申.
双向链表（Double Linked List）
热门推荐
Hacket_Xu的博客
08-28 1万+
虽然单向链表能够100%解决逻辑关系为“一对一”数据的存储问题，但在解决那些需要大量查找前趋节点的问题是，单向链表无疑是不能用了，因为单向链表适合“从前往后”查找，并不适合“从后往前”查找。如果要提高链表的查找效率，那双向链表（双链表）无疑是首选。双向链表字面上的意思是“双向”的链表，如图1所示。图1 - 双向链表示意图双向指各个节点之间的逻辑关系是双向的，该链表通常只有一个头节点。......
数据结构——双向链表（保姆级教程，包学包会）
m0_74459304的博客
05-14 5821
1.双向链表的概念 双向链表就是带头双向循环链表 我们在学完单链表之后，就感觉这个非常简单了，他的主要表现就是拥有头节点，链表永不为空，不需要二级指针；可以通过一个节点找到上一个或者下一个节点；头尾相连呈环状。 他主要结构是由prev、next、data，这三个结构组成，通过prev找到前一个节点，next就不用多说了。
【数据结构】双向链表
m0_73648729的博客
06-28 4443
和单向链表一样，双向链表每个节点都是由结构体组成的数据类型，但是双向链表结构体中增加了一个指向前一个节点的指针。//方便修改数据类型//指向下一个节点的指针//指向前一个节点的指针//存储的数据}LTNode;我们今天要将的是带哨兵卫头节点的双向循环链表，它的头节点不存储有效数据，头节点中的prev指针指向最后一个节点。
双向链表(数据结构)(C语言)
outdated_socks的博客
05-08 3847
双向链表的结构体定义、双向链表的初始化、关于无头单向非循环链表无需初始化函数，顺序表、带头双向循环链表需要的思考、双向链表在pos位置之前插入x、双向链表的打印 双链表删除pos位置的结点、双向链表的尾插、关于单链表的尾插需要用到二级指针，双向链表不需要用到二级指针的思考、双向链表的判空、双向链表的尾删、双向链表的头插、双向链表的头删、双向链表查找值为x的结点、双向链表的销毁、双向链表的修改、双向链表删除值为x的结点、双向链表计算结点总数(不计phead)、双向链表获取第
C语言 数据结构双向链表简单实例
08-31
主要介绍了C语言 数据结构双向链表简单实例的相关资料,需要的朋友可以参考下
C语言数据结构之双向循环链表的实例
08-30
主要介绍了C语言数据结构之双向循环链表的实例的相关资料,需要的朋友可以参考下
C语言实现双向链表
09-03
本文给大家分享的是一段使用C语言实现双向链表的代码，完全是根据自己的理解和认识来编写的，希望大家能够喜欢，文章的最后附上了一个网友写的对于双向链表删除节点、插入节点、双向输出等操作的代码，也非常不错，推荐给大家
C语言实现数据结构和双向链表操作
01-21
数据结构 双向链表的实现 双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。 双向链表结点的类型描述： //双向链表的类型描述 typedef ...
C语言实现双向链表DuLiST.c
03-24
C语言实现的双向链表，在codeblocks下经过很多测试，程序不会崩。 visual studio下经过少量修改即可运行
acwing算法提高之数据结构--并查集
最新发布
YMWM_的博客
04-23 218
acwing算法提高之数据结构--并查集
Day10-Java进阶-泛型&数据结构(树)&TreeSet 集合
weixin_68063226的博客
04-21 321
当每次添加节点的颜色是黑色当每次添加节点的颜色是红色/*TreeSet集合的特点体验 : 排序, 去重*/以下以返回值全为 -1 (倒序排序为例)
【数据结构（邓俊辉）学习笔记】向量02——动态空间管理
weixin_44399845的博客
04-22 844
介绍vector动态空间管理策略，递增算法和倍增算法分析。
使用C语言实现双向链表的全部功能
04-05
双向链表（Doubly Linked List）是一种数据结构，它与单向链表相似，但是每个节点除了指向下一个节点的指针之外，还有一个指向上一个节点的指针。这使得在双向链表中可以方便地向前或向后遍历节点。以下是使用C语言实现双向链表的全部功能的代码： ```c #include <stdio.h> #include <stdlib.h> // 定义双向链表的节点结构体 typedef struct Node { int data; struct Node* prev; struct Node* next; } Node; // 初始化双向链表 Node* init() { Node* head = (Node*)malloc(sizeof(Node)); head->data = -1; head->prev = NULL; head->next = NULL; return head; } // 在双向链表末尾添加节点 void append(Node* head, int data) { Node* new_node = (Node*)malloc(sizeof(Node)); new_node->data = data; new_node->prev = head; new_node->next = NULL; Node* p = head; while (p->next != NULL) { p = p->next; } p->next = new_node; } // 在双向链表指定位置插入节点 void insert(Node* head, int pos, int data) { Node* new_node = (Node*)malloc(sizeof(Node)); new_node->data = data; Node* p = head; for (int i = 0; i < pos; i++) { p = p->next; if (p == NULL) { printf("Error: position out of range\n"); return; } } new_node->prev = p->prev; new_node->next = p; p->prev->next = new_node; p->prev = new_node; } // 删除双向链表指定位置的节点 void remove_node(Node* head, int pos) { Node* p = head; for (int i = 0; i < pos; i++) { p = p->next; if (p == NULL) { printf("Error: position out of range\n"); return; } } p->prev->next = p->next; if (p->next != NULL) { p->next->prev = p->prev; } free(p); } // 获取双向链表指定位置的节点的数据 int get(Node* head, int pos) { Node* p = head; for (int i = 0; i < pos; i++) { p = p->next; if (p == NULL) { printf("Error: position out of range\n"); return -1; } } return p->data; } // 修改双向链表指定位置的节点的数据 void set(Node* head, int pos, int data) { Node* p = head; for (int i = 0; i < pos; i++) { p = p->next; if (p == NULL) { printf("Error: position out of range\n"); return; } } p->data = data; } // 获取双向链表的长度 int length(Node* head) { Node* p = head; int len = 0; while (p->next != NULL) { len++; p = p->next; } return len; } // 打印双向链表的所有节点的数据 void print(Node* head) { Node* p = head->next; while (p != NULL) { printf("%d ", p->data); p = p->next; } printf("\n"); } // 反向打印双向链表的所有节点的数据 void reverse_print(Node* head) { Node* p = head; while (p->next != NULL) { p = p->next; } while (p->prev != NULL) { printf("%d ", p->data); p = p->prev; } printf("\n"); } // 释放双向链表的所有节点的内存 void destroy(Node* head) { Node* p = head->next; while (p != NULL) { Node* q = p; p = p->next; free(q); } free(head); } int main() { Node* head = init(); append(head, 1); append(head, 2); append(head, 3); insert(head, 1, 4); remove_node(head, 2); set(head, 2, 5); printf("Length: %d\n", length(head)); print(head); reverse_print(head); destroy(head); return 0; } ``` 在上面的代码中，`init`函数用于初始化双向链表，返回一个头节点；`append`函数用于在双向链表末尾添加一个节点；`insert`函数用于在双向链表指定位置插入一个节点；`remove_node`函数用于删除双向链表指定位置的节点；`get`函数用于获取双向链表指定位置的节点的数据；`set`函数用于修改双向链表指定位置的节点的数据；`length`函数用于获取双向链表的长度；`print`函数用于打印双向链表的所有节点的数据；`reverse_print`函数用于反向打印双向链表的所有节点的数据；`destroy`函数用于释放双向链表的所有节点的内存。在`main`函数中，我们对双向链表进行了一些操作，例如添加节点、插入节点、删除节点、修改节点、获取长度、打印节点等等。最后，我们使用`destroy`函数释放了双向链表的内存。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

慕斯( ˘▽˘)っ

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

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

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

打赏作者

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

抵扣说明：

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

余额充值