王道数据结构课后代码题p40 第7——12题 （c语言代码实现）

最新推荐文章于 2024-06-01 13:53:57 发布
最新推荐文章于 2024-06-01 13:53:57 发布
阅读量913 收藏 25
点赞数 22
文章标签： 数据结构 算法 c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46702681/article/details/134872295
版权

目录

7.设在一个带表头结点的单链表中所有元素结点的数据值无序，试编写一个函数，删除表中所有介于给定的两个值(作为函数参数给出)之间的元素的元素 （c语言代码实现）

8.给定两个单链表，编写算法找出两个链表的公共结点（c语言代码）

9.给定一个带表头结点的单链表，写出算法 : 按递增次序输出单链表中各结点的数据元素并释放结点 （c语言代码实现)

10.将一个带头结点的单链表A分解为两个带头结点的单链表A和B，使A表中含有原表中序号为奇数的元素,而B表中含有原表中序号为偶数的元素,且保持其相对顺序不变（c语言代码）

11.C={a1,b1,a2,b2,...,an,bn}为线性表，采用带头结点的单链表存放，设计一个就地算法，将其拆分为两个线性表，使得A={a1..an},B={bn,.,b1}

12.在一个递增有序的线性表中，有数值相同的元素存在。若存储方式为单链表，设计算法去掉数值相同的元素,使表中不再有重复的元素,例如(7,10,10,21,30,42,42,42,51,70)将变为(7,10,21,30,42,51,70)。

7.设在一个带表头结点的单链表中所有元素结点的数据值无序，试编写一个函数，删除表中所有介于给定的两个值(作为函数参数给出)之间的元素的元素 （c语言代码实现）

     本题代码为（有注释）

void delete(linklist* L, int min, int max)//删除给定的两个值之间的元素
{
	lnode* p = (*L)->next, * q = *L;
	while (p != NULL)
	{
		if (p->data > min && p->data < max)//判断在是否在两个值的中间
		{
			q->next= p->next;//使q的后继指向p的后继
			free(p);//释放p的内存
			p = q->next;//使p指向q的后继
		}
		else
		{
			q = q->next;//q跟p都想后遍历
			p = p->next;
		}
	}
}

完整测试代码

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode,*linklist;
int n = 6;
int a[6] = { 3,2,4,9,8,7 };
void buildlinklist(linklist* L)
{
	*L = (lnode*)malloc(sizeof(lnode));
	(*L)->next = NULL;
	int i = 0;
	lnode* s = *L, * r = *L;
	for (i = 0; i < n; i++)
	{
		s = (lnode*)malloc(sizeof(lnode));
		s->data = a[i];
		s->next = r->next;
		r->next = s;
		r = s;
	}
	r->next = NULL;
}
void delete(linklist* L, int min, int max)//删除给定的两个值之间的元素
{
	lnode* p = (*L)->next, * q = *L;
	while (p != NULL)
	{
		if (p->data > min && p->data < max)//判断在是否在两个值的中间
		{
			q->next= p->next;//使q的后继指向p的后继
			free(p);//释放p的内存
			p = q->next;//使p指向q的后继
		}
		else
		{
			q = q->next;//q跟p都想后遍历
			p = p->next;
		}
	}
}
void print(linklist* L)
{
	lnode* k = (*L)->next;
	while (k != NULL)
	{
		printf("%d ", k->data);
		k = k->next;
	}
}
int main()
{
	linklist L;
	buildlinklist(&L);
	printf("原始单链表为：");
	print(&L);
	delete(&L,2,6);
	printf("\n删除后的单链表为：");
	print(&L);
	return 0;
}

8.给定两个单链表，编写算法找出两个链表的公共结点（c语言代码）

 两个链表有公共结点，就是两个链表从某一结点开始，它们的next都指向同一个结点

本题代码如下

int length(linklist* L)//计算链表长度
{
    int j = 0;
    lnode* p = (*L)->next;
    while (p != NULL)
    {
        j++;
        p = p->next;
    }
    return j;
}
linklist* findcommon(linklist* L1, linklist* L2)
{
    int len1 = length(L1);//计算两个链表的长度
    int len2 = length(L2);
    int dist = 0;
    linklist longlist, shortlist;//分别指向长的链表和短的链表
    if (len1 > len2)//L1较长
    {
        longlist = (*L1)->next;
        shortlist = (*L2)->next;
        dist = len1 - len2;//表长之差
    }
    else//L2表长
    {
        longlist = (*L2)->next;
        shortlist = (*L1)->next;
        dist = len2 - len1;
    }
    while (dist--)//表长的先遍历到第dist个结点
        longlist = longlist->next;
    while (longlist != NULL)//同步寻找共同结点
    {
        if (longlist->data== shortlist->data)//找到第一个公共结点
            return longlist->data;
        else//没没找到就继续寻找
        {
            longlist = longlist->next;
            shortlist = shortlist->next;
        }
    }
    return NULL;
}

完整测试代码

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
    int data;
    struct lnode* next;
} lnode, * linklist;
int a[5] = { 1,3,5,6,7};
int b[4] = { 2,9,6,7};
int n1 = 5;
int n2 = 4;
void buildlinklist(linklist* L, int arr[], int n)
{
    *L = (lnode*)malloc(sizeof(lnode));
    (*L)->next = NULL;
    int i = 0;
    lnode* s = *L, * r = *L;
    for (i = 0; i < n; i++)
    {
        s = (lnode*)malloc(sizeof(lnode));
        s->data = arr[i];
        s->next = r->next;
        r->next = s;
        r = s;
    }
    r->next = NULL;
}
int length(linklist* L)//计算链表长度
{
    int j = 0;
    lnode* p = (*L)->next;
    while (p != NULL)
    {
        j++;
        p = p->next;
    }
    return j;
}
linklist* findcommon(linklist* L1, linklist* L2)
{
    int len1 = length(L1);//计算两个链表的长度
    int len2 = length(L2);
    int dist = 0;
    linklist longlist, shortlist;//分别指向长的链表和短的链表
    if (len1 > len2)//L1较长
    {
        longlist = (*L1)->next;
        shortlist = (*L2)->next;
        dist = len1 - len2;//表长之差
    }
    else//L2表长
    {
        longlist = (*L2)->next;
        shortlist = (*L1)->next;
        dist = len2 - len1;
    }
    while (dist--)//表长的先遍历到第dist个结点
        longlist = longlist->next;
    while (longlist != NULL)//同步寻找共同结点
    {
        if (longlist->data== shortlist->data)//找到第一个公共结点
            return longlist->data;
        else//没没找到就继续寻找
        {
            longlist = longlist->next;
            shortlist = shortlist->next;
        }
    }
    return NULL;
}
int main()
{
    linklist L1;
    linklist L2;
    linklist L3 = (lnode*)malloc(sizeof(lnode));
    buildlinklist(&L1, a, n1);
    buildlinklist(&L2, b, n2);
    L3->data= findcommon(&L1, &L2);
    if (L3 != NULL)
    {
        printf("找到公共节点: %d\n", L3->data);
    }
    else
    {
        printf("没有找到公共节点\n");
    }
    return 0;
}

9.给定一个带表头结点的单链表，写出算法 : 按递增次序输出单链表中各结点的数据元素并释放结点 （c语言代码实现)

    本题代码如下（有注释）

void delete_min(linklist* head)
{
	while ((*head)->next != NULL)//循环到只剩下头节点
	{
		lnode* pre = *head;//pre为元素最小结点的前驱结点指针
		lnode* p = (*head)->next;//p为工作指针
		lnode* q;//指向被删除的结点
		while (p->next != NULL)//找到最小的结点
		{
			if (p->next->data < pre->next->data)
				pre = p;//记住当前最小值的前驱
			p = p->next;
		}
		printf("%d ", pre->next->data);//输出最小值结点的数据
		q = pre->next;//p指向最小结点
		pre->next = q->next;//pre后继指向q的后继
		free(q);//释放q结点
	}
	free(*head);//释放头节点
}

完整测试代码

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode,*linklist;
int n = 5;
int a[5] = { 2,1,9,8,7 };
void buildlinklist(linklist* head)//建立单链表
{
	*head = (lnode*)malloc(sizeof(lnode));
	(*head)->next = NULL;
	int i = 0;
	lnode* s = *head, * r = *head;
	for (i = 0; i < n; i++)
	{
		s = (lnode*)malloc(sizeof(lnode));
		s->data = a[i];
		s->next = r->next;
		r->next = s;
		r = s;
	}
	r->next = NULL;
}
void delete_min(linklist* head)
{
	while ((*head)->next != NULL)//循环到只剩下头节点
	{
		lnode* pre = *head;//pre为元素最小结点的前驱结点指针
		lnode* p = (*head)->next;//p为工作指针
		lnode* q;//指向被删除的结点
		while (p->next != NULL)//找到最小的结点
		{
			if (p->next->data < pre->next->data)
				pre = p;//记住当前最小值的前驱
			p = p->next;
		}
		printf("%d ", pre->next->data);//输出最小值结点的数据
		q = pre->next;//p指向最小结点
		pre->next = q->next;//pre后继指向q的后继
		free(q);//释放q结点
	}
	free(*head);//释放头节点
}
int main()
{
	linklist head;
	buildlinklist(&head);
	delete_min(&head);
	return 0;
}

10.将一个带头结点的单链表A分解为两个带头结点的单链表A和B，使A表中含有原表中序号为奇数的元素,而B表中含有原表中序号为偶数的元素,且保持其相对顺序不变（c语言代码）

  设置一个访问变量（初值为0），每访问一个结点序号自动加1，然后根据序号的奇偶性将结点插入到A表或B表中，用while循环重复以上操作直到表尾

本题代码如下

linklist discreat(linklist* L)
{
	lnode* B = (lnode*)malloc(sizeof(lnode));//创建B表的表头
	B->next = NULL;//B表初始化
	int i = 0;
	lnode* p = (*L)->next;//p为工作指针
	lnode* ra = *L,*rb=B;//ra指向A表尾，rb指向B表尾
	while (p != NULL)
	{
		i++;
		if (i % 2 == 0)//处理偶数序列的链表结点
		{
			rb->next = p;
			rb = p;
		}
		else//处理原序号为奇数的结点
		{
			ra->next = p;
			ra = p;
		}
		p = p->next;//p指向下一个待处理的结点
	}
	ra->next = NULL;
	rb->next = NULL;
	return B;
}

完整测试代码

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode,*linklist;
int n = 6;
int a[6] = { 1,2,3,4,5,6 };
void buildlinklist(linklist* L)
{
	*L = (lnode*)malloc(sizeof(lnode));
	(*L)->next = NULL;
	lnode* s = *L, * r = *L;
	int i = 0;
	for (i = 0; i < n; i++)
	{
		s = (lnode*)malloc(sizeof(lnode));
		s->data = a[i];
		s->next = r->next;
		r->next = s;
		r = s;
	}
	r->next =NULL;
}
linklist discreat(linklist* L)
{
	lnode* B = (lnode*)malloc(sizeof(lnode));//创建B表的表头
	B->next = NULL;//B表初始化
	int i = 0;
	lnode* p = (*L)->next;//p为工作指针
	lnode* ra = *L,*rb=B;//ra指向A表尾，rb指向B表尾
	while (p != NULL)
	{
		i++;
		if (i % 2 == 0)//处理偶数序列的链表结点
		{
			rb->next = p;
			rb = p;
		}
		else//处理原序号为奇数的结点
		{
			ra->next = p;
			ra = p;
		}
		p = p->next;//p指向下一个待处理的结点
	}
	ra->next = NULL;
	rb->next = NULL;
	return B;
}
void print(linklist* L)//输出单链表
{
	lnode* q = (*L)->next;
	while (q)
	{
		printf("%d ", q->data);
		q = q->next;
	}
}
int main()
{
	linklist L,B;
	buildlinklist(&L);
	printf("原始单链表为：");
	print(&L);
	B=discreat(&L);
	printf("\nA链表为：");
	print(&L);
	printf("\nB链表为：");
	print(&B);
	return 0;
}

11.C={a1,b1,a2,b2,...,an,bn}为线性表，采用带头结点的单链表存放，设计一个就地算法，将其拆分为两个线性表，使得A={a1..an},B={bn,.,b1}

 本题A链表应用尾插法，B链表应用头插法

linklist chaifen(linklist* L)//A链表用尾插法，B链表用头插法
{
	lnode* B = (lnode*)malloc(sizeof(lnode));
	B->next = NULL;
	lnode* p = (*L)->next, * ra = *L, * q;//p为工作指针，ra始终指向A的为结点
	while (p != NULL)
	{
		ra->next = p;
		ra = p;//将*p链接到A的表尾
		p = p->next;
		if (p != NULL)
		{
			q = p->next;//用q记录p的后继
			p->next = B->next;//将*p插入到B的前端
			B->next = p;
			p = q;
		}
	}
	ra->next = NULL;//A为结点的next域置空
	return B;
}

完整测试代码

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode,*linklist;
int n = 6;
int a[6] = { 1,2,3,4,5,6 };
void buildlinklist(linklist* L)
{
	*L = (lnode*)malloc(sizeof(lnode));
	(*L)->next = NULL;
	int i = 0;
	lnode* s = *L, * r = *L;
	for (i = 0; i < n; i++)
	{
		s = (lnode*)malloc(sizeof(lnode));
		s->data = a[i];
		s->next = r->next;
		r->next = s;
		r = s;
	}
	r->next = NULL;
}
linklist chaifen(linklist* L)//A链表用尾插法，B链表用头插法
{
	lnode* B = (lnode*)malloc(sizeof(lnode));
	B->next = NULL;
	lnode* p = (*L)->next, * ra = *L, * q;//p为工作指针，ra始终指向A的为结点
	while (p != NULL)
	{
		ra->next = p;
		ra = p;//将*p链接到A的表尾
		p = p->next;
		if (p != NULL)
		{
			q = p->next;//用q记录p的后继
			p->next = B->next;//将*p插入到B的前端
			B->next = p;
			p = q;
		}
	}
	ra->next = NULL;//A为结点的next域置空
	return B;
}
void print(linklist* L)//输出单链表
{
	lnode* k = (*L)->next;
	while (k)
	{
		printf("%d ", k->data);
		k = k->next;
	}
}
int main()
{
	linklist L, B;
	buildlinklist(&L);
	printf("原始单链表为：");
	print(&L);
	B = chaifen(&L);
	printf("\nA链表为：");
	print(&L);
	printf("\nB链表为：");
	print(&B);
	return 0;
}

12.在一个递增有序的线性表中，有数值相同的元素存在。
若存储方式为单链表，设计算法去掉数值相同的元素,使表中不再有重复的元素,例如(7,10,10,21,30,42,42,42,51,70)将变为(7,10,21,30,42,51,70)。

由于是有序表，所有相同值域的结点都是相邻的。用p扫描递增单链表L，若*p结点的值域等于其后继结点的值域，则删除后者，否则p移向下一个结点

本题代码如下

void deleterepeat(linklist* L)//删除重复的元素
{
	lnode* p = (*L)->next, * q;//p为扫描工作指针
	while (p->next!= NULL)
	{
		q = p->next;//q指向p的后继
		if (p->data == q->data)//如果p的后继与p相等
		{
			p->next = q->next;//p的后继就指向q的后继，也就是p的后继的后继
			free(q);//释放q结点
		}
		else
		{
			p = p->next;//p继续往后遍历
		}
	}
}

完整测试代码

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode,*linklist;
int n = 10;
int a[10] = { 7,10,10,21,30,42,42,42,51,70 };
void buildlinklist(linklist* L)
{
	*L = (lnode*)malloc(sizeof(lnode));
	(*L)->next = NULL;
	lnode* s = *L, * r = *L;
	int i = 0;
	for (i = 0; i < n; i++)
	{
		s = (lnode*)malloc(sizeof(lnode));
		s->data = a[i];
		s->next = r->next;
		r->next = s;
		r = s;
	}
	r->next = NULL;
}
void deleterepeat(linklist* L)//删除重复的元素
{
	lnode* p = (*L)->next, * q;//p为扫描工作指针
	while (p->next!= NULL)
	{
		q = p->next;//q指向p的后继
		if (p->data == q->data)//如果p的后继与p相等
		{
			p->next = q->next;//p的后继就指向q的后继，也就是p的后继的后继
			free(q);//释放q结点
		}
		else
		{
			p = p->next;//p继续往后遍历
		}
	}
}
void print(linklist* L)//输出的单链表
{
	lnode* k = (*L)->next;
	while (k != NULL)
	{
		printf("%d ", k->data);
		k = k->next;
	}
}
int main()
{
	linklist L;
	buildlinklist(&L);
	printf("原单链表为：");
	print(&L);
	deleterepeat(&L);
	printf("\n修改后的链表为：");
	print(&L);
	return 0;
}

努力敲代码的小火龙
关注
  • 22
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
C语言学习笔记 p40指针笔试面试题讲解(1).zip
01-20
C++面试题库，大厂进阶之路； 一份涵盖大部分 C++ c程序员所需要掌握的核心知识；涉及C++面试常问题、设计模式、数据结构、操作系统及网络等
华为P40安装谷歌框架2.2——aurora
09-22
华为P40安装谷歌框架步骤2 1、设置——系统和更新——日期和时间——自动设置 2、安装下面的3个软件
华为P40安装谷歌框架步骤1——backup.rar
09-21
华为P40下载谷歌框架第一步。 使用手机浏览器下载（对浏览器无要求），在文件管理中找到下载的安装包 1、文件管理——长按压缩包——更多——解压至——内部存储——选择目录——Huawei（位置在中间偏下）——勾选右...
华为P40安装谷歌框架2.3——google store.apk
09-22
华为P40安装谷歌框架步骤2 1、设置——系统和更新——日期和时间——自动设置 2、安装下面的3个软件
华为P40安装谷歌框架步骤2.1——GMS.apk
09-22
华为P40安装谷歌框架步骤2 1、设置——系统和更新——日期和时间——自动设置 2、安装下面的3个软件
浙江大学数据结构MOOC-课后习题-第十讲-排序4 统计工龄
chan1ee的博客
05-28 348
题目汇总。
【数据结构】链表与顺序表的比较
最新发布
SWsunlight的博客
06-01 880
顺序表和链表比较
短期总结（数据结构学完有感）
chan1ee的博客
05-29 308
从刚开始废寝忘食地学习，到中途自己过度关注题目的AC而忽略自己对知识的掌握，再到后面的沉下心去好好钻研，这段时间的收获确实很大，不光是知识层面，还有自己对学习的认识和态度。我的OS学习计划参考了其他博主的心得，打算先看哈工大的网课，并且完成课后Lab，最后参考《操作系统真想还原》动手实现一个小型操作系统。这18天我几乎没有休息过，每天早上7:30起床，晚上9点多才回宿舍，太久没有这么高强度学习过，确实让我的身心都有点疲劳了。接下来的打算就是，和女朋友一起玩几天，然后就开始投身于操作系统的学习。
C-数据结构-树转存广义表-广义表转成树-实例
aqiangdeba的博客
05-28 319
【代码】C-数据结构-树转存广义表-广义表转成树-实例。
树--搜索二叉树
Beau Wang
05-29 848
线索二叉树充分利用了指针空间，同时又便于寻找结点的前驱结点和后继结点。线索二叉树适用于经常需要遍历寻找结点前驱或者后继结点的二叉树。
【数据结构】二叉树-堆（下）-链式二叉树
s_little_monster的博客
05-31 2078
二叉树堆的相关内容以及链式二叉树的相关内容
【数据结构】P1 数据结构是什么、算法怎样度量
weixin_43098506的博客
05-28 939
数据结构基础知识，数据结构三要素，算法是什么，算法的时间复杂度、空间复杂度、两大公式
数据结构之堆（优先级队列）
zhyhgx的博客
05-28 760
详细的讲解了堆的创建，向下调整，向上调整，以及其基本操作
《java数据结构》--栈的详解
hyldzbg的博客
05-28 612
栈是一种不同于链表和顺序表的储存数据结构，它对存储数据和取出数据有着特殊的要求🤔。首先栈只能从一端存储数据，这也是栈最大的特点，这也导致在栈中存取数据都必须遵循的原则😊，即先存入的数据只能最后拿出来，嗯🤔你可以把它想做一个细长的圆桶，你要往里放东西肯定是先放在最下面，当放满这个圆桶后你要再拿出刚开始放的那个，就必须把它上面的东西都拿出来才行。下面我来画图演示一下(画的不好请见谅🦊)：一般我们将栈用来存取的一端叫做我们常常说取栈顶元素就是去取离栈顶最近的元素(也就是图中的3)，另一端叫做。
python基础-数据结构-序列类型--list、tuple、range
qq_44511981的博客
05-28 950
这篇文章将介绍 Python 中的序列类型，包括通用序列类型、不可变序列类型和可变序列类型，以及它们的构建方式、常见操作和自定义方法。具体内容包括： 通用序列类型： 介绍序列类型的基本概念和通用操作。 不可变序列类型： 讨论不可变序列类型的特点和常见操作。 可变序列类型： 探讨可变序列类型的特点、常见操作和自定义方法。 列表（list）： 详细介绍列表的构建方法、排序操作等。 元组（tuple）： 介绍元组的构建方式和常见用法。 Range 对象： 简要介绍 range 对象的特点和用法。 此外，还将给出
数据结构--树
zy1215058242的博客
05-27 610
在本节开始之前我们先来了解一下在树的学习中，我们需要了解哪些概念。叶节点或终端节点：度为0的节点称为叶节点；如上图：B、C、H、I...等结点为叶结点。。双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的双亲节点；如上图：A是B的父结点。孩子节点或子节点：一个节点含有子树的根节点称为该节点的子节点；如上图：B是A的孩子结点。树的高度或深度：树中节点的最大层次；如上图：树的高度为4。非终端结点或分支结点：度不为0的结点；如上图：D、E、F、G...等结点为分支结点。
浙江大学数据结构MOOC-课后习题-第九讲-排序2 Insert or Merge
chan1ee的博客
05-28 438
题目汇总。
【数据结构】-- 栈
prettyxian的博客
05-28 453
引入：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。压栈：栈的插入操作叫做进栈压栈入栈，。出栈：栈的删除操作叫做出栈。。注意：入栈顺序是DCBA，出栈顺序不一定是ABCD，可以边入边出所以，入栈顺序是DCBA ，出栈顺序有很多种。栈的实现：数组，单向链表，双向链表都能够实现栈：数组：单链表：用单链表实现栈有一个问题，单链表不能回头，如图这么设计，在压栈之后，不方便出栈。所以我们可以以开头作为栈顶，然后对链表头插来实现栈，出栈的时候使用头删。
03-树1 树的同构(浙大数据结构PTA习题）
Learner_HJ的博客
05-28 586
给定两棵树 T1​ 和 T2​。如果 T1​ 可以通过若干次左右孩子互换就变成 T2​，则我们称两棵树是“同构”的。例如图1给出的两棵树就是同构的，因为我们把其中一棵树的结点A、B、G的左右孩子互换后，就得到另外一棵树。而图2就不是同构的。现给定两棵树，请你判断它们是否是同构的。输入给出2棵二叉树的信息。
RL78/F12使用ANI0电源电压检测示例代码
05-25
以下是RL78/F12使用ANI0电源电压检测的示例代码： ```c #include "iodefine.h" void init_ANI0(void); void init_ADC(void); unsigned short get_ADC_result(void); int main(void) { unsigned short adc_result...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

努力敲代码的小火龙

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

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

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

打赏作者

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

抵扣说明：

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

余额充值