双向链表、循环链表以及循环双向链表的整理

最新推荐文章于 2023-03-10 22:33:35 发布
最新推荐文章于 2023-03-10 22:33:35 发布
阅读量262 收藏 3
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xwl666666/article/details/114638037
版权

双向链表

引言

页面的前进与回退

在这里插入图片描述

已知某指针q的位置，求指针p。
在这里插入图片描述

由于单链表节点中只有一个指向其直接后继结点的指针域，因此若已知某结点的指针域为p，找其前驱结点只能从该链表的头结点开始，顺链查找，直到找到某个结点q的直接后继为p为止。q所指的结点即为p的直接前驱，其时间复杂度为O(n)。

所以要想让其时间复杂度达到O(1)，可以选择增加一个指向直接前驱的指针域。
在这里插入图片描述

双向链表的基本操作

//定义结构体变量
typedef struct node{
	int data;			//data域存放数据
	struct node *prev;	//prev指针域存放上一个结点的地址
	struct node *next;	//next指针域存放下一个结点的地址
}LNode,*Linklist;

//创建头结点
Linklist CreatList(); 

//双向链表判空操作
int isEmpty(Linklist head); 

//链表的创建 [头插法]
void ListByInsertHead(Linklist head );

//链表的创建[尾插法]
void ListByInsertTail(Linklist head );
 
//将p结点插入q结点之前 
void Insert(LNode *p, LNode *q);

//删除给定结点
void delete_Node(LNode *p); 

//删除链表
void delete_List(LNode *p);

链表创建头结点[初始化]

在这里插入图片描述

/**
*创建链表，返回头指针。
**/
Linklist CreatList(){
	Linklist head = (Linklist)malloc(sizeof(LNode));//创建头结点
	head->next=NULL;	//将next指针域置空
	head->prev=NULL;	//将prev指针域置空
	return head;		//返回头结点
}

/**
*双向链表判空操作
**/
int isEmpty(Linklist head){
	if(head->next==NULL && head->prev==NULL){
		//为空 
		return 1;
	}
	//不为空 
	return 0; 	
}

如何连接我相信大家画图都是知道的，但是有时候代码跑不起来的原因就是因为插入的次序没有。

链表头插法创建

在这里插入图片描述

断开两个连接

在这里插入图片描述

我们先看一下原图

在这里插入图片描述

断的次序(head->next后断）：

在这里插入图片描述

特殊情况：

当只存在head结点时，head的next指针域为空。

在这里插入图片描述

已知Head结点和p结点，上面共四步：

Head->next=p;(1)
p->prev=Head;(2)
Head->next->prev=p;(3)
p->next=Head->next;(4)

3 4 1

/**
*头插法创建链表
**/
void ListByInsertHead(Linklist head ){
	
	LNode *p;	//指针p用来接受数据，进行插入
	int x;
	while(scanf("%d",&x)&&x!=-1){
		p=(Linklist)malloc(sizeof(LNode)) ;
		p->data=x;
		
        //头插法
        //只有头结点时，头结点的next域为NULL，不存在prev指针域，第一步要放在第三步之前，此时未更新head->next
		if(head->next!=NULL){	
			head->next->prev=p;
		}
		p->next=head->next;	//单链表头插操作
		head->next=p;		//单链表头插操作
		p->prev=head;		//将p的prev指针域指向head（这一步放哪都行）
        
	}
	return ;
}

链表尾插法创建

在这里插入图片描述

在这里插入图片描述

此时有四步改动

p->next=s;(1)
p=s;(2)
s->prev=p;(3)
s->next=p->next;(4)
//还有一种写法是s->next=NULL;

3 2

/**
*尾插法创建链表
**/
void ListByInsertTail(Linklist head ){

	LNode *p,*s;	//指针p用来保存尾指针位置，指针s用来存数据进行插入
	p=head;//只有头结点时，头结点即为最后一个结点
	int x;
	while(scanf("%d",&x)&&x!=-1){
		s=(Linklist)malloc(sizeof(LNode)) ;
		s->data=x;
    
        //尾插法
        s->next=p->next;//s的结点指向尾结点p的下一个，即NULL
		p->next=s;//将尾结点的next指针指向要插入的结点
        //第三步和第四步不能交换
		s->prev=p;//要插入的结点的前一个结点更新为尾结点
		p=s;//将尾结点更新为新插入的结点
        
       

    }
	
	return ;	
}

/**
*尾插法创建链表第二种写法
**/
void ListByInsertTail(Linklist head ){

	LNode *p,*s;	//指针p用来保存尾指针位置，指针s用来存数据进行插入
	p=head;//只有头结点时，头结点即为最后一个结点
	int x;
	while(scanf("%d",&x)&&x!=-1){
		s=(Linklist)malloc(sizeof(LNode)) ;
		s->data=x;
    
        //尾插法
		p->next=s;//将尾结点的next指针指向要插入的结点
        //第二步和第三步不能交换
		s->prev=p;//要插入的结点的前一个结点更新为尾结点
		p=s;//将尾结点更新为新插入的结点
    }
	s->next=NULL;//尾结点指向为空
    
	return ;	
}

指定结点前插入

在q结点前插入p结点

在这里插入图片描述

在这里插入图片描述

此处共有四处改动

p->prev=q->prev;(1)
q->prev->next=p;(2)
p->next=q;(3)
q->prev=p;(4)

/**
*指定结点前插入（在q结点前插入p结点）
**/

void Insert(LNode *p, LNode *q){
    //只有等q指针前面那个结点的相关操作处理完之后才能修改q->prev
	p->prev=q->prev;
	q->prev->next=p;
    
	p->next=q;
	q->prev=p;
}

链表删除

在这里插入图片描述

在这里插入图片描述

特殊：p为尾指针在这里插入图片描述

上述有三处改动

p->prev->next=p->next;(1)
p->next=p->prev(2)
free(p)(3)

/**
*删除指定结点
**/

void delete_Node(LNode *p){
	p->prev->next=p->next;
	if(p->next!=NULL){
		p->next->prev=p->prev;
	}                                                    
	free(p);
}

双向链表完整代码

#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
typedef struct node{
	int data;
	struct node *prev;
	struct node *next;
}LNode,*Linklist;

//创建链表
Linklist CreatList(); 

//双向链表判空操作
int isEmpty(Linklist head); 

//链表的创建 [头插法]
void ListByInsertHead(Linklist head );

//链表的创建[尾插法]
void ListByInsertTail(Linklist head );
 

//将p结点插入q结点之前 
void Insert(LNode *p, LNode *q);

//删除p结点
void delete_Node(LNode *p); 

//删除链表
void delete_List(LNode *p); 

//打印链表
void print_List(Linklist head);


int main(){
	
	Linklist head = CreatList();
	printf("%d\n",isEmpty(head)); 
	ListByInsertTail(head);
	print_List(head);
	printf("\n");
	Linklist head1 = CreatList();
	ListByInsertHead(head1);
	print_List(head1);
//	LNode *t = (Linklist)malloc(sizeof(LNode));
//	t->data=10;
//	Insert(t,head->next);
//	print_List(head);
//	printf("\n");
//	delete_Node(t);
//	print_List(head);
//	delete_List(head);
	return 0;
	
} 

Linklist CreatList(){
	Linklist head = (Linklist)malloc(sizeof(LNode));
	head->next=NULL;
	head->prev=NULL;
	return head;
}

int isEmpty(Linklist head){
	if(head->next==NULL && head->prev==NULL){
		//为空 
		return 1;
	}
	//不为空 
	return 0; 	
}

void ListByInsertHead(Linklist head ){
	
	LNode *p;
	int x;
	while(scanf("%d",&x)&&x!=-1){
		p=(Linklist)malloc(sizeof(LNode)) ;
		p->data=x;
		
		if(head->next!=NULL){
			head->next->prev=p;
		}
		p->next=head->next;
		head->next=p;
		p->prev=head;
	}
	return ;
}

void ListByInsertTail(Linklist head ){

	LNode *p,*s;
	p=head;
	int x;
	while(scanf("%d",&x)&&x!=-1){
		s=(Linklist)malloc(sizeof(LNode)) ;
		s->data=x;
		s->next=p->next; 
		p->next=s;
		s->prev=p;
		p=s;
	}
	//s->next=NULL;
	return ;
	
	
}
				
void Insert(LNode *p, LNode *q){
	p->prev=q->prev;
	q->prev->next=p;
	p->next=q;
	q->prev=p;
}


void delete_Node(LNode *p){
	p->prev->next=p->next;
	if(p->next!=NULL){
		p->next->prev=p->prev;
	}                                                    
	free(p);
}

void delete_List(LNode *p){
	LNode *t,*temp;
	t=p->next;
	while(t){
		temp=t->next;
		delete_Node(t);
		t=temp;
		print_List(p);
	}
	free(p);
}
void print_List(Linklist head){
	Linklist p;
	p=head;
	while(p->next){
		p=p->next;
		printf("%d ",p->data);	
	} 
	
	system("pause"); 
	printf("\n");
	while(p->prev){	
		printf("%d ",p->data);
		p=p->prev;
	}
}

循环双向链表的实现

小思考：自己实现循环双向链表

循环双向链表和双向链表的操作基本一致， 注意由于head指针的prev域和尾指针的next域不为空，因此部分操作需要增加对这两个指针的连接

双向循环链表完整代码：

#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
typedef struct node{
	int data;
	struct node *prev;
	struct node *next;
}LNode,*Linklist;

//创建链表
Linklist CreatList(); 

//双向循环链表判空操作
int isEmpty(Linklist head); 

//链表的创建 [头插法]
void ListByInsertHead(Linklist head );

//链表的创建[尾插法]
void ListByInsertTail(Linklist head );
 

//将p结点插入q结点之前 
void Insert(LNode *p, LNode *q);

//删除p结点
void delete_Node(LNode *p); 

//删除链表
void delete_List(LNode *p); 

//打印链表
void print_List(Linklist head);


int main(){
	
		Linklist head = CreatList();
		printf("%d\n",isEmpty(head));
	ListByInsertTail(head);
	print_List(head);
	printf("\n");
	//Linklist head1 = CreatList();
	//ListByInsertHead(head1);
	//print_List(head1);
	LNode *t = (Linklist)malloc(sizeof(LNode));
	t->data=10;
	Insert(t,head->next);
	print_List(head);
	printf("\n");
	delete_Node(t);
	print_List(head);
	delete_List(head);
	return 0;
	
} 

Linklist CreatList(){
	Linklist head = (Linklist)malloc(sizeof(LNode));
	head->next=head;
	head->prev=head;
	return head;
}

int isEmpty(Linklist head){
	if(head->next==head && head->prev==head){
		//为空 
		return 1;
	}
	//不为空 
	return 0; 	
}

void ListByInsertHead(Linklist head ){
	
	LNode *p;
	int x;
	while(scanf("%d",&x)&&x!=-1){
		p=(Linklist)malloc(sizeof(LNode)) ;
		p->data=x;
		
		head->next->prev=p;
		p->next=head->next;
		head->next=p;
		p->prev=head;
	}
	return ;
}

void ListByInsertTail(Linklist head ){

	LNode *p,*s;
	p=head;
	int x;
	while(scanf("%d",&x)&&x!=-1){
		s=(Linklist)malloc(sizeof(LNode)) ;
		s->data=x;
		s->next=p->next;
		//增加代码：尾指针所指的下一个结点即头指针的prev修改为要插入的结点，即将头指针与新要插入的结点连接起来
		p->next->prev=s; 
		p->next=s;
		s->prev=p;
		p=s;
	}
	return ;
	
	
}
				
void Insert(LNode *p, LNode *q){
	p->prev=q->prev;
	q->prev->next=p;
	p->next=q;
	q->prev=p;
}


void delete_Node(LNode *p){
	p->prev->next=p->next;
	//if(p->next!=NULL){ //p->next不会为空，可删去 
	p->next->prev=p->prev;
//	}                                                    
	free(p);
}

void delete_List(LNode *p){
	LNode *t,*temp;
	t=p->next;
	while(t!=p&&t!=p){//判断条件改为当t又绕回一圈时即链表只剩一个结点 
		temp=t->next;
		delete_Node(t);
		t=temp;
		print_List(p);
		printf("\n");
	}
	free(p);
}
void print_List(Linklist head){
	Linklist p;
	p=head->next;
	while(1){
	
		printf("%d ",p->data);	
		if(p->next==head){
			break;
		}	
		p=p->next;
	} 
	
	system("pause"); 
	printf("\n");
	while(1){	
		printf("%d ",p->data);
		
		if(p->prev==head){
			break;
		}
		p=p->prev;
	}
}

模拟链表

引言

前面介绍的链表都是由指针实现的，链表中结点的分配和回收都是动态的，称为"动态链表“。与之对应的，还有一种"静态链表"，又称模拟链表,静态链表由数组实现，每个数据元素除了存储数据信息外，还要存储逻辑相邻的下一个数据元素在数组中的位置。可见，静态链表虽然是用数组实现的，但是逻辑相邻的数据元素不一定在物理上是相邻的。

下表就是一个模拟链表，他的存储顺序是：a1->a2->a3->a4->a5->……，但是他的物理顺序是a4->a2-a3->a1->a5->……

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aCqcRdob-1615363269774)(.\双向链表.assets\image-20201208221730863.png)]

模拟链表通过两个数组实现链式存储，data数组用来存储当前结点的数据，next数组用来存储下一个结点的位置。(是不是感觉和链表很像)，通过相同点的数组下标，标识每一个元素存储的数据及下一个结点的位置信息，一样的，第一个结点并没有存放任何元素。

模拟链表的基本操作

//定义next=-1为空 
typedef struct{
	int data;
	int next;
}imitate;

//定义静态链表 
imitate im[Maxsize];

//链表表头和新要插入的位置 
int head,pos;

//初始化链表
void init_list(); 

//链表判空操作
int isEmpty() ;

//链表增加结点
void add_toList(); 

//指定位置之后插入结点
int add_postoList(int point,int x); 

//删除指定位置元素
int delete_pos_list(int point);

模拟链表的初始化

在这里插入图片描述

/**
*链表初始化
**/
void init_list(){
	head=0;//头结点放在0位置
	pos=1; 
	im[0].next=-1; 
}

链表判空

int isEmpty(){
	if(im[head].next==-1){
		return 1;
	}
	return 0;
}

链表增加节点

在这里插入图片描述

在这里插入图片描述

/**
*链表尾部增加结点
**/
void add_toList(int x){
    //从头开始遍历，找到尾结点
	int i=head;
	
	while(im[i].next!=-1){
		i=im[i].next;
	}
	
    im[pos].data=x;//读入新要插入的元素
    
	im[i].next = pos;//将尾结点的next指针指向新要插入的元素
	im[pos].next = -1;//将新插入的元素的尾指针置空
	++pos;
}

指定位置后增加结点

在这里插入图片描述

在这里插入图片描述

/**
*链表指定位置后增加结点 成功返回1 失败返回0
*point变量表示链表中第几个数据
**/
int add_postoList(int point,int x){
	
	for(int i= im[head].next;i!=-1;i=im[i].next){
		if((--point)==0){//找到那个要增加结点的位置
			im[pos].data=x;//读入值yuanxie
			im[pos].next=im[i].next;//新插入的值的下一个结点为第point个位置的结点的下一个结点
			im[i].next=pos;//第point个结点的下一个结点更新为新插入的结点
			++pos;//插入点后移
			return 1;
		}
	}
	return 0; 
}

删除指定位置的结点

在这里插入图片描述

在这里插入图片描述

/**
*链表指定位置删除结点 成功返回1 失败返回0
*point变量表示链表中第几个数据
**/
int delete_pos_list(int point){
	point=point-1;//找要删除的结点的前一个结点
	for(int i= im[head].next;i!=-1;i=im[i].next){
		if((--point)==0){		//循环找到那个结点
			im[i].next=im[im[i].next].next; //该结点等于要删除的结点的下一个结点。
			return 1;
		}
	}
	return 0;
}
xwl666666
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
第二章——双链表和循环双链表
weixin_55835175的博客
09-22 504
线性表——双链表和循环双链表 双链表的定义在链表那里就介绍过了，这里就不重复介绍了。 双链表和循环双链表 同样地，我们用结构体来声明链表中的一个结点： struct DLinkNode{ElemType data; DLinkNode *prior; DLinkNode *next;}; //定义双链表结点类型,prior指向前一个结点,next指向后一个结点 和单链表基本是一样的。 双链表和循环双链表基本运算的实现 这里会提供双链表和循环双链表基本运算的实现及代码。 建立双链表——头插法 和单链表
循环链表、双向链表、循环双向链表
Shao_yihao的博客
07-22 86
文章目录二，循环链表一些操作1，将两个循环链表合并O(1)O(1)O(1)三，双向链表一些操作1，双向链表的元素插入2，双向链表的元素删除四，双向循环链表一些操作1，尾插法插入元素2，直接创建一个含n个元素的循环双向链表3，求循环链表的元素个数（双向循环链表的遍历）4，元素的查找5，打印链表几种链表的比较顺序存储结构与链式存储结构的比较 二，循环链表 表中最后一个结点的指针域指向头结点 优点：从表中任意一个结点出发都可以找到表中其它结点 注意：循环链表的遍历结束条件 循环链表中使用尾指针要比使用头指针更方
数据结构（五）——双链表与循环链表
流逝
08-03 1400
数据结构（五) —— 双链表和循环链表
c语言双循环链表,循环链表之双循环链表（C语言版）
weixin_35822833的博客
05-19 569
依然沿袭过去的风格，进入双循环链表之前，先提另一种结构，双向链表，先有了双向链表再有了双循环链表。这两种结构和单链表一样都有带头结点和不带头结点之分。我们先来看一下这几种结构的结构图:双链表双循环链表既然单向链表有普通的链表也就是不循环的链表、那么双向链表也一样，也有普通的双向链表和双向循环链表；也有带头结点，不带头结点的结构，这里依然是两种结构都给出算法，但是普通的循环链表不写，这里只写循环双链...
数据结构系列2——双向链表和双向循环链表
喜欢C艹的小白的博客
09-23 4454
引入：双向链表是在原来的单链表基础上增加了一个可以保存某节点的上一个节点的指针域的数据结构，相较于单链表而言，双向链表在查找数据的时候所花费的时间是要小于单链表的，因为其可进可退。其缺点就是增删节点比单链表麻烦，而且在创建节点的时候也需要多申请一个指针存储空间。双向循环链表，顾名思义就是在双向链表的基础上，将尾节点的“right”指针指向头结点，同时头结点的“left”指针指向尾节点，它和双向链表的不同是，其判断节点是否遍历完毕的条件不再是是否为空，而是是否回到了头结点，优点是可以在任意位置插入数据，时间.
循环双链表与双循环链表差别_实施循环双链表| C程序
cumtb2009的博客
07-05 739
循环双链表与双循环链表差别Solution: 解： Input: The data of each node 输入：每个节点的数据 Output: The circular doubly linked list 输出：圆形双向链表 Data structure used: A circular doubly linked list where each node contains a ...
顺序表链表双向链表循环链表等操作
LAYA_的博客
10-21 127
一些考研的顺序表，链表，循环列表，双向链表的操作；晚点打栈队列那些，有需要可以关注一下。 自行复制吧，自己敲的，只能说可能存在健壮性的问题。 顺序表 代码如下： #define Initsize 50 typedef struct { int *data; int length; }sqlist; sqlist Initlist(sqlist &l) { l.data = new int[Initsize]; if (!l.data) { cout << "申请失败"
循环链表和双向链表.ppt
09-20
循环链表和双向链表是两种特殊类型的线性链表，它们在数据结构中扮演着重要角色，尤其在处理线性关系的数据时。下面将详细讨论这些概念。 首先，我们来看带头结点的链表。在普通链表的基础上，带头结点的链表会在...
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
双向循环链表使用实例.doc
09-21
在本文中，我们将深入探讨如何使用C++实现双向循环链表。双向循环链表是一种特殊的数据结构，每个节点不仅包含数据，还包含两个指针，分别指向前一个节点和后一个节点，形成一个首尾相接的循环链。这种数据结构在...
一个关于双向链表的基本操作程序
10-20
本程序是一个关于双向链表的操作，包括插入节点，删除节点，遍历等
双向循环链表-C语言实现.doc
09-21
这篇文档主要介绍的是如何在C语言中实现双向循环链表的...总的来说，这篇文档详细介绍了如何使用C语言实现双向循环链表的初始化、插入、删除和查找操作，对于理解链表数据结构以及在C语言中操作链表有很好的指导作用。
Python双向循环链表实现方法分析
09-20
【Python双向循环链表实现方法分析】 Python中的双向循环链表是一种特殊的数据结构，它具有两个指针，分别指向当前节点的前一个节点（prev）和后一个节点（next），并且链表的最后一个节点的next指针指向第一个节点...
单链表&循环链表&双向链表的不同
qq_53830608的博客
01-14 2308
循环链表： ①判空条件为：p==plist或者p->next==NULL; ②判断结尾不同：循环链表的结尾又回到了头（是一个圈圈一样的循环）：p==plist；而单链表的结尾时NULL：p==NULL。 ③循环链表可以从一个结点到达任意节点，而单链表只能顺着链表一直查找下去(因为循环链表可以一直循环下去，而单链表只能走一遍）。 双向链表： 增加了前驱结点，在涉及前驱结点的头插、尾插、删除操作上有所不同，判空条件仍为p==NULL. ①头插与尾插的最后一部插入时，需要把前驱结点连接上，头插法
单链表、双链表、循环链表简介
z2141830440的博客
03-10 742
对于一个链表，是由一系列不必在内存中相连的结构组成，每一个结构均含有表元素和指向包含该元素下一个表结构的指针（我们称之为Next指针）,它们也叫数据域和指针域。最后一个表结构的Next指针指向NULL，ANSI C规定NULL为零。（图1-2中箭头表示的就是Next指针）
【数据结构】循环链表和双向链表
Jacky_Feng的博客
09-14 1902
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 对于单链表，由于每个结点只存储了向后的指针，到了为标志就停止了向后链的操作。这样，当我们需要找到某个结点的前驱就没办法了。如何从链表中的任一结点出发，访问到链表的全部结点？循环链表就是解决这个麻烦的重要方法。 一、循环链表的定义 1、定义 将单链表中终端结点的指针端由空指针改为指向头指针，就使整个单链表形..
学《数据结构》越学越聪明--第三章》》》栈和队列（一） 栈
qq_46163557的博客
12-12 1502
栈 栈的概述 栈是一种只能从一端插入的线性表只能在同一个端进行插入和删除 栈的几个概念 允许插入和删除的一端称为栈顶 另一端称为栈底 栈中没有元素时称为空栈 栈的插入操作通常称为进栈或入栈 栈的删除操作通常称为出栈或退栈 栈的特点： 栈的主要特点是后进先出即后进栈的元素先出栈。栈也被称为后进先出表 设一个栈的输入序列为a,b,c,d，则借助一个栈所得到的输出序列不可能是_D__ A,c,d,b,a        B,d,c,b,a  &nbs
python双向链表以及双向循环链表
tt丫的博客
01-29 1424
深度学习入门小菜鸟，希望像做笔记记录自己学的东西，也希望能帮助到同样入门的人，更希望大佬们帮忙纠错啦~侵权立删。 目录 一、双向链表和双向循环链表概念 二、双向链表的实现 1、建立节点对象 2、链表对象的初始定义 3、判断链表是否为空 4、获取链表长度 5、向头部添加节点 6、向尾部添加节点 7、指定位置插入节点 8、删除指定位置的节点 9、查找是否有该数据的节点 10、遍历输出整个链表 11、输入数据创建链表 12、具体调用 三、双向循环链表的实现 1、建立节点对象 2
mpu6050陀螺仪使用方法开发教程文档.docx
最新发布
07-30
mpu6050陀螺仪使用方法
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值