数据结构（c语言）单链表部分操作

最新推荐文章于 2022-10-19 12:52:32 发布
最新推荐文章于 2022-10-19 12:52:32 发布
阅读量963 收藏 2
点赞数
分类专栏： 数据结构——C语言 文章标签： 数据结构 c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kkh01421/article/details/115353983
版权

  • 链表是由许多相同数据类型的数据按照特定顺序排列而成的线性表。其优点是数据的插入和删除都相当方便，缺点是设计数据结构十分麻烦。

一、单链表

（一）动态分配内存

c语言中可使用头文件下stdlib.h中的malloc（）和free（）函数在程序执行期间动态分配与释放内存。

  • 动态分配内存方式如下：
数据类型*指针名称 = （数据类型*）malloc （sizeof（数据类型）*n）；
n=1即表示一个变量

变量或对象在使用动态内存分配后，必须进行内存的释放。否则会造成“内存漏失”现象。

  • 释放动态分配变量方式如下：
free(指针名称)
  • 例如：
#include<stdio.h>
#include<stdlib.h>

int main(void){
	
	float *piVal=(float*)malloc(sizeof(float));//动态分配一块浮点数内存空间 
	*piVal=3.14;
	int *piCal=(int*)malloc(sizeof(int));//动态分配一块整数内存空间 
	*piCal=1000;
	 printf("piVal所指向的地址内容为%f\n\n",*piVal);
	 printf("piCal所指向的地址内容为%d\n\n",*piCal);
	 free(piVal);//释放piVal所指向的内存空间 
	 free(piCal);//释放piCal所指向的内存空间 
	 
} 
/*piVal所指向的地址内容为3.140000

  piCal所指向的地址内容为1000*/
  • 实例一
#include<stdio.h>
#include<stdlib.h>
#include<cstring>
int main(void) {
	char* s1 = (char*)malloc(sizeof(char) * 10);
	strcpy(s1, "Hello,C!");
	printf("%s ", s1);
	printf("s1=%d", s1);
	printf("\n");
	char* s2 = (char*)malloc(sizeof(char) * 10);
	strcpy(s2, "Hello,C!");
	printf("%s ", s2);
	printf("s2=%d", s2);
	free(s1);
	free(s2);
}
Hello,C! s1=2036736
Hello,C! s2=2059152
  • 实例二
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main(void){
	struct student{
		char name[20];
		int score;
	};
	
	student* s=(student*)malloc(sizeof(student));
	strcpy(s->name,"zhangsan");
	printf(s->name);
	s->score=85;
	printf("\nscore=%d",s->score);
	free(s);
} 
zhangsan
score=85

（二）单向链表

  • 一个单向链表节点基本上由两个元素构成，即数据字段和指针组成，而指针将会指向下一个元素在内存中的位置。
  • 在单向链表中第一个节点是“链表头指针”，指向最后一个节点的指针设为NULL，表示它是“链表尾”，不知向任何地方。
  • 注意，除非必要否则不可移动链表头指针。

1、建立单向链表

  • 在C语言中，若以动态分配产生链表节点的方式，可以先定义一个结构数据类型，接着在结构中定义一个指针变量，其数据类型与结构相同，作用是在指向下一个链表节点，另外结构中至少要有一个数据字段。
struct student
{
    char name[20];
    int score;
struct student *next;
}s1,s2;
  • 完成结构数据类型定义之后，就可以动态建立链表中每个节点。假设现在要新增一个节点至链表的末尾，且ptr指向链表的第一个节点，则程序上必须设计以下4步
  1. 动态分配内存空间给新节点使用
  2. 将原链表尾部的指针（next）指向新元素所在的内存地址
  3. 将ptr指针指向新节点的内存位置，表示这是新的链表尾部
  4. 由于新结点当前为链表的最后一个元素，所以将它的指针（next）指向NULL
  • 例如将s1的next变量指向s2的内存地址，而且s2的next变量指向NULL
s1.next = &s2;
s2.next = NULL;
  • 建立学生节点的单向链表算法
#include<stdio.h>
#include<stdlib.h>

int main(void){
	struct student{
		char name[20];
		char no[20];
		int Math;
		int Eng;
		struct student*next;
	};
	typedef struct student s_data;
	s_data*ptr;//存取指针 
	s_data*head;//链表头指针
	s_data*new_data;//新增元素所在位置的指针
	head=(s_data*)malloc(sizeof(s_data));//新增链表头的元素
	ptr=head;//设置存取指针的位置
	ptr->next=NULL;//当前无下一元素
	int select; 
	do
	{
		printf("(1)新增 (2)离开 =>");
		scanf("%d",&select);
		if(select!=2){
			printf("姓名 学号 数学成绩 英语成绩：");
			scanf("%s %s %d %d",ptr->name,ptr->no,&ptr->Math,&ptr->Eng);
			new_data=(s_data*)malloc(sizeof(s_data));//新增下一个元素 
			ptr->next=new_data;//存取指针设置为新元素所在的位置
			new_data->next=NULL;//下一个元素的next先设置为null
ptr=ptr->next; 
		}
	}while(select!=2);
}

2、遍历单向链表

  • 遍历单向链表过程中，就是要使用指针运算访问链表中的每一个节点。例如以上例子中，使用结构指针ptr作为链表的读取游标，一开始指向链表的头。每次读完链表的一个节点就将ptr往下一个节点移动，直到ptr指向NULL为止。
ptr=head;//设置存取指针从头开始
while(ptr->next!=NULL){
    {
        printf("姓名：%s\t 学号：%s\t 数学成绩：%d\t 英语成绩：%d\n",
                   ptr->name,ptr->no,ptr->Math,ptr->Eng);
        ptr=ptr->next;//将ptr移往下一个元素
    }
  • 实例一
#include<stdio.h>
#include<stdlib.h>

int main(void){
	struct student{
		char name[20];
		char no[10];
		int math;
		int Eng;
		struct student*next;
	};
	typedef struct student data;
	data*ptr;
	data*head;
	data*new_data;
	head=(data*)malloc(sizeof(data));
	ptr=head;
	ptr->next=NULL;
	int select;
	float math_sum,math_ave=0;
	float Eng_sum,Eng_ave=0;
	int n=0;
	do{
		printf("(1) 新增 (2) 离开=>");
		scanf("%d",&select);
		if(select!=2){
		printf("姓名 学号 数学成绩 英语成绩："); 
		scanf("%s %s %d %d",ptr->name,ptr->no,&ptr->math,&ptr->Eng);
		new_data=(data*)malloc(sizeof(data));
		ptr->next=new_data;
		new_data->next=NULL;
		ptr=ptr->next;
		n++;
	}
	}while(select!=2);
	ptr=head;
	while(ptr->next!=NULL){
		printf("姓名：%s\t 学号：%s\t 数学成绩：%d\t 英语成绩：%d\n",
		ptr->name,ptr->no,ptr->math,ptr->Eng);
		math_sum+=ptr->math;
		Eng_sum+=ptr->Eng;
		ptr=ptr->next;
	}
	math_ave=math_sum/n;
	Eng_ave=Eng_sum/n;
	printf("======================================\n");
	printf("数学成绩平均值为：%.1f 英语成绩平均值为%.1f",math_ave,Eng_ave);
}
(1) 新增 (2) 离开=>1
姓名 学号 数学成绩 英语成绩：张三 01 65 89
(1) 新增 (2) 离开=>1
姓名 学号 数学成绩 英语成绩：李四 02 98 68
(1) 新增 (2) 离开=>1
姓名 学号 数学成绩 英语成绩：王麻子 03 68 96
(1) 新增 (2) 离开=>2
姓名：张三       学号：01        数学成绩：65    英语成绩：89
姓名：李四       学号：02        数学成绩：98    英语成绩：68
姓名：王麻子     学号：03        数学成绩：68    英语成绩：96
======================================
数学成绩平均值为：77.0 英语成绩平均值为84.3

3、释放单向链表节点的空间

  • 在使用动态方式分配链表的内存后，事后必须进行释放内存的操作。除了利用free（）函数或者delete运算符来释放单个节点的内存外，还可以利用单向链表的遍历技巧来收回整个链表的内存空间。算法如下：
while(first!=NULL){
    ptr=first;//first为头指针
    first=first->next;//逐一遍历
    free(ptr);
}
  • 实例
#include<stdio.h>
#include<stdlib.h>

int main(void){
	struct student {
		char name[20];
		int age;
		struct student*next;
	};
	typedef struct student data;
	data*ptr;
	data*head;
	data*new_data;
	head=(data*)malloc(sizeof(data));
	ptr=head;
	ptr->next=NULL;
	int select;
	do{
		printf("（1）新增 （2）离开 =>");
		scanf("%d",&select);
		if(select!=2){
			printf("姓名 年龄：");
			scanf("%s %d",ptr->name,&ptr->age);
			new_data=(data*)malloc(sizeof(data));
			ptr->next=new_data;
			new_data->next=NULL;
			ptr=ptr->next; 
		}
		}while(select!=2);
	ptr=head;
	while(ptr->next!=NULL){
		printf("姓名：%s\t 年龄：%d\n",ptr->name,ptr->age);
		ptr=ptr->next;
		ptr=head;
	}
	printf("========================================\n");
	while(head!=NULL){
		ptr=head;
		head=head->next;
		free(ptr);
	}
	printf("所有节点释放完毕！"); 
}
	

（1）新增 （2）离开 =>1
姓名 年龄：张三 20
（1）新增 （2）离开 =>1
姓名 年龄：李四 18
（1）新增 （2）离开 =>2
姓名：张三       年龄：20
姓名：李四       年龄：18
========================================
所有节点释放完毕！

3、单项链表插入新的节点

单向链表插入新节点有三种方式。加到第一个节点之前，加到最后一个节点之后以及加到此链表中间任意位置。

  • 新节点插入第一个节点之前，即成为此链表的首节点：只需要把新节点的指针指向链表原来的第一个节点，再把链表头指针指向新节点即可。
newnode->next=first;
first=newnode;
  • 新节点插入最后一个节点之后：只需要把链表的最后一个节点的指针指向新节点，新节点的指针再指向NULL即可。
ptr->next=newnode;
newnode->next=NULL;
  • 将新节点插入链表中间的位置：例如插入的节点是在X与Y之间，只要将X节点的指针指向新节点，新节点的指针指向Y节点即可。
newnode->next=x->next;
x->next=newnode;
  • 实例
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(void){
	struct employee{
		int num,score;
		char name[10];
		struct employee *next;
	};
	typedef struct employee data;
	data*ptr;
	data*head;
	data*new_data;
	head=(data*)malloc(sizeof(data));
	ptr=head;
	ptr->next=NULL;
	int select;
	do{
		printf("(1) 新增 (2) 离开 =>");
		scanf("%d",&select);
		if(select!=2){
			new_data=(data*)malloc(sizeof(data));
			new_data->next=NULL;
			printf("姓名 序号 薪资：");
			char name1[10];
			int num1;
			int score1;
			scanf("%s %d %d",name1,&num1,&score1);
			strcpy(ptr->name,name1);
			ptr->num=num1;
			ptr->score=score1;
			ptr->next=new_data;
			ptr=ptr->next; 
		} 
	}while(select!=2);
		for(int i=0;i<3;i++){
		printf("员工编号 薪水\t");
	}
	printf("\n--------------------------------------------\n");
	ptr=head;
	int cnt=0;
	ptr=head;
	while(ptr->next!=NULL){
		printf("[%d]\t ￥%d\t",ptr->num,ptr->score);
		cnt++;
		if(cnt%3==0){
			printf("\n");
		}
		
		ptr=ptr->next;
	}
	printf("\n--------------------------------------------\n");
	int se;
	data*new_e;
	do{
		printf("\n请输入要插入其后的员工编号，如输入的编号不在此链表中，\n");
		printf("\n新输入的员工节点将视为此链表的链表头部，要结束输入过程请输入-1:\n");
		scanf("%d",&se);
		if(se!=-1){
			new_e=(data*)malloc(sizeof(data));
			new_e->next=NULL;
			printf("请输入新插入的员工编号：");
			scanf("%d",&new_e->num);
			printf("请输入新插入的员工薪水：");
			scanf("%d",&new_e->score);
			printf("请输入新插入的员工姓名：");
			scanf("%s",new_e->name); 
			new_e->next=head;
			head=new_e; 
		}
	}while(se!=-1);
	printf("员工编号　姓名　薪水\t");
	printf("\n================================\n");
	ptr=head;
	while(ptr->next!=NULL){
		printf("[%d] [%s] [%d]\t\n",ptr->num,ptr->name,ptr->score);
		head=head->next;
		ptr=head;	
	}	 
}

(1) 新增 (2) 离开 =>1
姓名 序号 薪资：张三 01 5000
(1) 新增 (2) 离开 =>1
姓名 序号 薪资：李四 02 6500
(1) 新增 (2) 离开 =>1
姓名 序号 薪资：赵四 04 5800
(1) 新增 (2) 离开 =>2
员工编号 薪水   员工编号 薪水   员工编号 薪水
--------------------------------------------
[1]      ￥5000 [2]      ￥6500 [4]      ￥5800

--------------------------------------------

请输入要插入其后的员工编号，如输入的编号不在此链表中，

新输入的员工节点将视为此链表的链表头部，要结束输入过程请输入-1:
01
请输入新插入的员工编号：03
请输入新插入的员工薪水：3500
请输入新插入的员工姓名：王麻子

请输入要插入其后的员工编号，如输入的编号不在此链表中，

新输入的员工节点将视为此链表的链表头部，要结束输入过程请输入-1:
-1
员工编号　姓名　薪水
================================
[3] [王麻子] [3500]
[1] [张三] [5000]
[2] [李四] [6500]
[4] [赵四] [5800]

--------------------------------

4、单向链表删除节点

若要在链表中删除节点，根据所删除的节点位置会有三种情况

  • 删除链表的第一个节点将链表的头指针指向第二个节点即可。
ptr=head;
head=head->next;
free(ptr);
  • 删除链表的最后一个节点，只要指向最后一个节点的指针指向NULL即可
ptr->next = tail;
ptr->next = NULL;
free(tail);
  • 删除链表内的中间节点，只要将删除节点的前一个结点的指针，指向将要被删除的下一个节点即可。
Y = ptr->next;
ptr->next = Y->next;
free(Y);
  • 实例
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(void){
	struct employee{
		int num,score;
		char name[10];
		struct employee *next;
	};
	typedef struct employee data;
	data*ptr;
	data*head;
	data*new_data;
	head=(data*)malloc(sizeof(data));
	ptr=head;
	ptr->next=NULL;
	int select;
	do{
		printf("(1) 新增 (2) 离开 =>");
		scanf("%d",&select);
		if(select!=2){
			new_data=(data*)malloc(sizeof(data));
			new_data->next=NULL;
			printf("姓名 序号 薪资：");
			char name1[10];
			int num1;
			int score1;
			scanf("%s %d %d",name1,&num1,&score1);
			strcpy(ptr->name,name1);
			ptr->num=num1;
			ptr->score=score1;
			ptr->next=new_data;
			ptr=ptr->next; 
		} 
	}while(select!=2);
		for(int i=0;i<3;i++){
		printf("员工编号 薪水\t");
	}
	printf("\n--------------------------------------------\n");
	ptr=head;
	int cnt=0;
	ptr=head;
	while(ptr->next!=NULL){
		printf("[%d]\t ￥%d\t",ptr->num,ptr->score);
		cnt++;
		if(cnt%3==0){
			printf("\n");
		}
		
		ptr=ptr->next;
	}
	printf("\n--------------------------------------------\n");
	
	int se;
	do{
		printf("\n请输入要删除的员工编号，要结束删除过程请输入-1。（默认删除第一个）\n");
		scanf("%d",&se);
		if(se!=-1){
			if(se==1){
				ptr=head;
				head=head->next;
				free(ptr);
			}
		}
		
	}while(se!=-1);
	printf("员工编号　姓名　薪水\t");
	printf("\n================================\n");
	ptr=head;
	while(ptr->next!=NULL){
		printf("[%d] [%s] [%d]\t\n",ptr->num,ptr->name,ptr->score);
		head=head->next;
		ptr=head;	
	}	 
}
(1) 新增 (2) 离开 =>1
姓名 序号 薪资：1 1 1
(1) 新增 (2) 离开 =>1
姓名 序号 薪资：2 2 2
(1) 新增 (2) 离开 =>2
员工编号 薪水   员工编号 薪水   员工编号 薪水
--------------------------------------------
[1]      ￥1    [2]      ￥2
--------------------------------------------

请输入要删除的员工编号，要结束删除过程请输入-1。（默认删除第一个）
1

请输入要删除的员工编号，要结束删除过程请输入-1。（默认删除第一个）
-1
员工编号　姓名　薪水
================================
[2] [2] [2]

快乐麦肯
关注
专栏目录
数据结构-单链表基本操作-C语言代码
suxiaorui的博客
01-22 6万+
单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
计算机二级题目之结构体与共用体练习学习
shallon的博客
12-16 606
#include <stdio.h> #include <stdlib.h> #define N 8 typedef struct list { int data; struct list *next; } SLIST; void fun( SLIST *h, int x) { SLIST *p, *q, *s; s=(SLIST *)malloc(sizeof(SLIST)); /**********found*******...
程序改错。以下程序用于打印输出结构体数组的所有元素。
qq_52698632的博客
02-03 3128
程序改错。以下程序用于打印输出结构体数组的所有元素。 struct s { char name[10]; int age; } main() { struct s a[3] = {”John”,19,”Paul”,17,”Marry”,18}; int *p; for(p = a; p < 3; p++) { printf("%s,%d\n", p->name, p->age ); } } 答案： #include<stdio.h> struct s { ch
安徽师范大学2021年898计算机答案
qq_41684160的博客
01-11 1773
安师大2021年硕士研究生招生考试898初试试题解答 一、程序填空题 ​ 用递归方法求下式的值，请将程序补充完整，使程序得出正确的结果。 #include<stdio.h> float fun(float x,int n) { float temp; if(n==0) temp=1; else if(n==1) temp=x; else temp=((2*n-1)*x*fun(x,n-1)-(n-1)*fun(x,n-1))/n;//填空 return
初始结构体
m0_62969222的博客
10-19 453
概念：结构体是一些值的集合，这些值被称为成员变量。结构体内的每个成员可以是不同类型的变量，可以是标量，数组指针，甚至可以是其他结构体。 理解：结构体是一个类型，类似于int，float，double等，但这个类型的名字是可以自定义的。这样讲可能也很难理解，我们可以在下面的讲解中慢慢理解。 结构体的声明： struct tag struct为结构体的关键字，tag是可以自定义的结构体标签，也就是给结构体的类型起个名字（类似于整型的类型名字是int，单精度的类型名字...
结构数组和结构指针
Peter_H
06-21 1719
数组名 数组名可以作为数组第一个元素的指针。我们由数组和指针的关系知道，a代表这个地址数值，它相当于一个指针，指向第一个元素（&a[0])，即指向数组的首地址。数组中的其他元素可以通过a的位移得到，此时的进阶是以数组中单个的元素类型为单位的，即a+i= & a[i]。 另外：（有关数组名取地址） &a代表的不是取a这个变量的地址，而是取数组的地址。虽然&a和a的内存...
数据结构C语言单链表上实现插入和删除的算法实验报告.docx
05-30
"数据结构C语言单链表上实现插入和删除的算法实验报告" 本文档是关于数据结构中的单链表实现插入和删除操作的算法实验报告，使用C语言编写，并提供了详细的实验步骤和实验结果。 单链表的基本操作 单链表是一种...
数据结构C语言-单链表操作实验
04-23
数据结构C语言版，单链表操作的菜单式实验，包括单链表的初始化、创建、求表长、插入删除元素、销毁和清空单链表等操作，具体操作根据屏幕提示进行。
数据结构单链表实验（C语言）
01-08
单链表的接本操作，有在单链表中插入，删除数据的功能，以及...1．单链表的数据结构的建立实现。 2．单链表元素结点插入操作实现。 3．单链表元素结点删除操作实现。 4．实现单链表的合并。 5．实现一元多项式的相加。
数据结构C语言版之单链表的逆置.cpp
10-07
数据结构老师布置的作业，运用课本代码，较为基础经典，适合大学本科在上数据结构这门课的同学参考，简单易懂，关于单链表的逆置问题
c语言实现通用数据结构（一）：通用链表
热门推荐
03-29 1万+
忽然想起来，大概在两年之前学习C语言的时候，曾经用C语言写过一些通用的数据结构。主要也就实现了链表、队列、椎、HashSet，还有HashMap。当时只是知道标准的C语言中没有这方面的类库，后来才知道有很多第三方的类似这样的类库。废话不多说，先把代码粘过来。 下面实现的是通用链表，注意链表中只存储了指针，没有储存实际的数据。
顺序表（完整操作）
qiao_yuzhou的专栏
02-12 1420
<br />#include<stdio.h><br />#include<stdlib.h><br />#include<malloc.h><br /><br />#define ListSize 100<br /><br />typedef int DataType;<br /><br />typedef struct<br />{<br />DataType data[ListSize];<br />int length;<br />}Seqlist;<br /><br />void InsertLi
. 和 ->使用的错误
寂纱
12-02 189
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define MAX 100 typedef struct list { int a[MAX]; int length; }List; （1） void creat(List l) { &gt; int i; &gt; printf("元素的个数:"); ...
求结构体平均成绩 || 本题要求实现一个函数，可统计结构体中成绩项的平均成绩。 结构体由两项组成：学号和成绩。
courage_sir的博客
08-17 4203
#include <stdio.h> #define N 20 typedef struct { char no[10]; double score; }RECORD; double avg(RECORD x[],int n); int main() { RECORD a[N]; int n,i; double av; scanf("%d",&n); for(i=0;i<n;i++) scanf("%s%l
【C语言】11.字符函数和字符串函数1
weixin_46293452的博客
10-19 289
学习C语言字符串和字符函数
C语言 结构体数组复制
wel2014的博客
12-19 5242
C语言复制函数分为3种，strcpy，strncpy，memcpy，适用场景如下： strcpy：字符串复制 strncpy：相同结构的指针数组复制 memcpy：对象复制，指针结构可以不同，指向的数组结构必须相同 ...
C语言二级第一套题（答案+解析）
Chlin.Rei的博客
04-25 3521
C语言二级第一套题（答案+解析） 一、选择题 一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈,然后再依次出栈,则元素出栈的顺序是( )。 A、12345ABCDE B、EDCBA54321 C、ABCDE12345 D、54321EDCBA 【解析】栈是先进后出的原则组织数据,所以入栈最早的最后出栈,所以选择B)。 下列叙述中正确的是( )。 A、循环队列有队头和队尾两个指针,因此,循环队列是非线性结构 B、在循环队列中,只需要队头指针就能反映队列中元素的动态变化情况
数据结构 静态顺序表的基础实现
目标架构师
02-27 420
数据结构 静态顺序表的基础实现
c语言十九：结构体
qq_33808440的博客
03-30 1942
结构体一 结构体数据类型的三种定义方式1.1 先定义类型，再定义变量（推荐）1.2 定义类型的同时定义变量1.3 定义一次性结构体1.4 注意事项二 结构体变量的初始化三 结构体变量成员值的清0（用memset）四 结构体变量的成员从键盘获取值五 相同结构体类型的变量之间赋值5.1 一个成员一个成员逐个赋值5.2 用=整体赋值5.3 用memcpy内存数据直接拷贝赋值六 结构体数组6.1 结构体数组的初始化七 定义一个结构体数组，从键盘为每个数组元素的每个成员赋值八 结构体指针8.1 定义一个结构体指针8.
数据结构c语言单链表基本操作
最新发布
10-20
单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。C语言中实现单链表的基本操作包括：创建链表、插入节点、删除节点、查找节点、遍历链表等。其中，插入节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值