2024 王道课后代码题 第二章 链表（下）(完全实现代码)

最新推荐文章于 2024-11-07 14:57:11 发布
最新推荐文章于 2024-11-07 14:57:11 发布
阅读量122 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53631431/article/details/132890630
版权

算法思想：单链表有序，可以依次向后查询，设置一个前驱pre指针,一个后继q指针，依次向后遍历，查找后一位链表元素的值是否与前一位相同，如果相同则删除该节点的值

具体代码实现:

#include <stdio.h>
#include <malloc.h>

typedef int ElemType;
typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;

LinkList TailInsert(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;//r为表尾指针
	scanf_s("%d", &x);
	while (x != -1)
	{
		s = (LinkList)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf_s("%d", &x);
	}
	r->next = NULL;
	return L;
}

void Print_LinkList(LinkList L) {
	if (L == NULL || L->next == NULL) { // 处理链表为空的情况
		printf("cilianbiao wei kong");
	}
	else {
		printf("建立的单链表为:");
		L = L->next;
		while (L != NULL)
		{
			printf("%d->", L->data);
			L = L->next;
		}
	}
}

LinkList delete_equeal(LinkList& L) {
	LNode* p, * pre,*q;//设置工作指针与其前驱节点
	p = L->next;
	q = p->next;//设置p的后继指针
	pre = L;
	LNode* r;//设置另一个工作指针
	while (q!=NULL)
	{
		if (q->data == p->data) {
			q = q->next;
			r = p->next;
			pre->next = p->next;
			free(p);
			p = r;
		}
		else
		{
			q = q->next;
			pre = p;
			p = p->next;
		}
	}
	return L;
}
int main() {
	LinkList L = NULL;
	TailInsert(L);
	Print_LinkList(L);
	printf("\n改变后的单链表为:\n");
	delete_equeal(L);
	Print_LinkList(L);
}

程序演示结果:

算法思想:依次比较链表A与链表B节点的大小如果谁更小，则利用头插法插入A链表中。

具体代码实现：

#include <stdio.h>
#include <malloc.h>

typedef int ElemType;
typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;

LinkList TailInsert(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;//r为表尾指针
	scanf_s("%d", &x);
	while (x != -1)
	{
		s = (LinkList)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf_s("%d", &x);
	}
	r->next = NULL;
	return L;
}

void Print_LinkList(LinkList L) {
	if (L == NULL || L->next == NULL) { // 处理链表为空的情况
		printf("cilianbiao wei kong");
	}
	else {
		printf("建立的单链表为:");
		L = L->next;
		while (L != NULL)
		{
			printf("%d->", L->data);
			L = L->next;
		}
	}
}

LinkList delete_equeal(LinkList& La,LinkList &Lb) {
	LNode* ra = La->next,*pa;
	LNode* rb = Lb->next,*pb;
	La->next = NULL;//断链
	while (ra!=NULL&&rb!=NULL)
	{
		if (ra->data < rb->data) {
			pa = ra->next;
			ra->next = La->next;//头插入
			La->next = ra;
			ra = pa;
		}
		else
		{
			pb = rb->next;
			rb->next = La->next;
			La->next = rb;
			rb = pb;
		}
	}
	while (ra!=NULL)
	{
		pa = ra->next;
		ra->next = La->next;//头插入
		La->next = ra;
		ra = pa;
	}while (rb != NULL)
	{
		pb = rb->next;
		rb->next = La->next;
		La->next = rb;
		rb = pb;
	}
	return La, Lb;
}
int main() {
	LinkList La = NULL;
	LinkList Lb = NULL;
	TailInsert(La);
	Print_LinkList(La);
	TailInsert(Lb);
	Print_LinkList(Lb);
	printf("\n改变后的单链表为:\n");
	delete_equeal(La,Lb);
	Print_LinkList(La);
}

具体运行结果展示:

具体代码实现：

void Search_common(LinkList& La,LinkList &Lb,LinkList &Lc) {
	LNode* ra = La->next,*pa;
	LNode* rb = Lb->next,*pb;
	LNode* r;
	Lc->next = NULL;
	r = Lc;	
	LNode* s = (LNode*)malloc(sizeof(LNode));
	while (ra!=NULL&&rb!=NULL)
	{
		if (ra->data < rb->data) {
			ra = ra->next;
		}
		else if(ra->data>rb->data)
		{
			rb = rb->next;
		}
		else
		{
			s->data = ra->data;
			r->next = s;
			r = s;
			ra = ra->next;
			rb = rb->next;
		}
	}
	r->next = NULL;
	Print_LinkList(Lc);
}

算法思想：设置指针依次寻找链表A与链表B中的元素，如果一方数据元素小于另一方则向后继续查找，找到相等的点时，将其尾插入A链表中。

具体代码实现：

#include <stdio.h>
#include <malloc.h>

typedef int ElemType;
typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;

LinkList TailInsert(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;//r为表尾指针
	scanf_s("%d", &x);
	while (x != -1)
	{
		s = (LinkList)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf_s("%d", &x);
	}
	r->next = NULL;
	return L;
}

void Print_LinkList(LinkList L) {
	if (L == NULL || L->next == NULL) { // 处理链表为空的情况
		printf("cilianbiao wei kong");
	}
	else {
		printf("建立的单链表为:");
		L = L->next;
		while (L != NULL)
		{
			printf("%d->", L->data);
			L = L->next;
		}
	}
}

void Search_common(LinkList& La,LinkList &Lb) {
	LNode* ra = La->next,*pa;
	LNode* rb = Lb->next,*pb;
	La->next = NULL;
	LNode* r=La;
	LNode* q, * p;
	while (ra!=NULL&&rb!=NULL)
	{
		if (ra->data < rb->data) {
			q = ra;
			ra = ra->next;
			free(q);
		}
		else if(ra->data>rb->data)
		{
			p = rb;
			rb = rb->next;
			free(p);
		}
		else{
			r->next = ra;
			r = ra;
			ra = ra->next;
			rb = rb->next;
		}
	}
	r->next = NULL;
}
int main() {
	LinkList La = NULL;
	LinkList Lb = NULL;
	TailInsert(La);
	Print_LinkList(La);
	TailInsert(Lb);
	Print_LinkList(Lb);
	printf("\n改变后的单链表为:\n");
	Search_common(La,Lb);
	Print_LinkList(La);
}

具体结果展示:

算法思想：1.如果B链表的长度大于A链表的长度，返回错误，B不是A 的连续子序列。

                  2.B链表长度小于A链表长度，则进行一一比对，将链表A逐步遍历看是否能有完全与B相对应的连续子序列如果有，则返回TRUE,否则返回FALSE.

具体代码实现：

#include <stdio.h>
#include <malloc.h>

typedef int ElemType;
typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;

LinkList TailInsert(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;//r为表尾指针
	scanf_s("%d", &x);
	while (x != -1)
	{
		s = (LinkList)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf_s("%d", &x);
	}
	r->next = NULL;
	return L;
}

void Print_LinkList(LinkList L) {
	if (L == NULL || L->next == NULL) { // 处理链表为空的情况
		printf("cilianbiao wei kong");
	}
	else {
		printf("建立的单链表为:");
		L = L->next;
		while (L != NULL)
		{
			printf("%d->", L->data);
			L = L->next;
		}
	}
}

bool Is_ture(LinkList La,LinkList Lb) {
	LNode* pre = La;
	LNode* q = La->next;
	LNode* p = Lb->next;
	while (q != NULL && p != NULL)
	{
		if (q->data == p->data) {
			q = q->next;
			p = p->next;//同时向后移动
		}
		else
		{
			pre = q;
			q =q->next;//La向后移动
			p = Lb->next;
		}
	}
	if (p == NULL) {
		printf("B是A的子序列");
		return true;
	}
	else
	{
		printf("B不是A的子序列");
		return false;
	}
}
int main() {
	LinkList La = NULL;
	LinkList Lb = NULL;
	TailInsert(La);
	Print_LinkList(La);
	TailInsert(Lb);
	Print_LinkList(Lb);
//	printf("\n改变后的单链表为:\n");
	Is_ture(La,Lb);
//	Print_LinkList(La);
}

程序运行截图：

算法思想：依次找双链表的前驱和后继，判断前驱和后继的值是否相等如果相等就依次向后移动，直到达到循环结束条件为止。

具体代码：

#include <stdio.h>
#include <malloc.h>

typedef int ElemType;
typedef struct LNode {
	ElemType data;
	struct LNode* next;
	struct LNode* prior;
}DNode, * DLinkList;//双链表结构体声明

DLinkList TailInsert(DLinkList& L) {
	int x;
	L = (DLinkList)malloc(sizeof(DNode));
	DNode* s, * r = L;//r为表尾指针
	scanf_s("%d", &x);
	while (x != -1)
	{
		s = (DLinkList)malloc(sizeof(DNode));
		s->data = x;
		r->next = s;
		s->prior = r;
		r = s;
		scanf_s("%d", &x);
	}
	r->next = L;
	L->prior = r;
	return L;
}

void Print_LinkList(DLinkList L) {
	DNode* r = L->next;
	if (L == NULL || L->next == NULL) { // 处理链表为空的情况
		printf("cilianbiao wei kong");
	}
	else {
		printf("建立的循环双链表为:");
		while (r!=L )
		{
			printf("%d->", r->data);
			r = r->next;
		}
	}
}
bool Is_duichen(DLinkList L) {
	DNode* p = L->next;
	DNode* q = L->prior;
	while (p->next!=q&& p!=q)
	{
		if (p->data == q->data)
		{
			p = p->next;
			q = q->prior;
		}
		else
		{
			printf("此循环双链表不对称");
			return false;
		}
	}
	printf("此循环双链表对称");
	return true;
}



int main() {
	DLinkList L = NULL;
	TailInsert(L);
	Print_LinkList(L); // 创建循环双链表
	Is_duichen(L);
}

运行结果展示：

算法思想：依次找到h1与h2的尾节点，然后将尾节点链接到下一个链表的头节点上，即可完成链表和合并。

具体代码实现：

#include <stdio.h>
#include <malloc.h>

typedef int ElemType;
typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;//双链表结构体声明

LinkList TailInsert(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;//r为表尾指针
	scanf_s("%d", &x);
	while (x != -1)
	{
		s = (LinkList)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf_s("%d", &x);
	}
	r->next = L;
	return L;
}

void Print_LinkList(LinkList &L) {
	LNode* r = L->next;
	if (L == NULL || L->next == NULL) { // 处理链表为空的情况
		printf("cilianbiao wei kong");
	}
	else {
		printf("建立的循环单链表为:");
		while (r!=L )
		{
			printf("%d->", r->data);
			r = r->next;
		}
	}
}
LinkList Merger_A_B(LinkList &La,LinkList &Lb) {
	LNode* r = La->next;
	LNode* p = Lb->next;
	while (r->next!=La)
	{
		r = r->next;
	}
	r->next = p;
	while (p->next!=Lb)
	{
		p = p->next;
	}
	p->next = La;
	return La;
}



int main() {
	LinkList La = NULL;
	LinkList Lb = NULL;
	TailInsert(La);
	Print_LinkList(La); // 创建循环双链表
	TailInsert(Lb);
	Print_LinkList(Lb);
	printf("\n改变后的单链表为:\n");
	Merger_A_B(La,Lb);
	Print_LinkList(La);
//	Print_LinkList(La);
}

结果展示：

算法思想：循环遍历单链表，直到删除完所有节点后，循环单链表为空则退出循环

具体代码展示：

#include <stdio.h>
#include <malloc.h>

typedef int ElemType;
typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;//单链表结构体声明

LinkList TailInsert(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;//r为表尾指针
	scanf_s("%d", &x);
	while (x != -1)
	{
		s = (LinkList)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf_s("%d", &x);
	}
	r->next = L;
	return L;
}

void Print_LinkList(LinkList &L) {
	LNode* r = L->next;
	if (L == NULL || L->next == NULL) { // 处理链表为空的情况
		printf("cilianbiao wei kong");
	}
	else {
		printf("建立的循环单链表为:");
		while (r!=L )
		{
			printf("%d->", r->data);
			r = r->next;
		}
	}
}
void Del_min(LinkList &L) {
	LNode* min_pre;
	LNode* min;
	LNode* pre;
	LNode* p;
	while (L->next != L)
	{
		p = L->next;
		pre = L;
		min_pre = pre;
		min = p;
		while (p != L)
		{
			if (min->data > p->data) {
				min_pre = pre;
				min = p;
			}
			pre = p;
			p = p->next;
		}
			printf("%d->", min->data);
			min_pre->next = min->next;
			free(min);
		
	}
	free(L);
}



int main() {
	LinkList L = NULL;
	TailInsert(L);
	Print_LinkList(L); // 创建循环单链表
	printf("\n改变后的单链表为:\n");
	Del_min(L);
}

具体结果展示：

初级程序员_成长之路
关注
2024王道数据结构第二章链表第4题
LHY的博客
10-22 75
试编写在带头结点的单链表L中删除一个最小值结点的高效算法（假设最小结点是唯一的）。
2024王道数据结构第二章链表第2题
LHY的博客
10-22 79
在带头结点的单链表中，删除所有值为x的结点，并释放其空间，假设值为x的结点不唯一，试编写算法以实现上述操作。
23王道数据结构代码题全解（三）
漫磋嗟
04-22 2926
此次更新链表（8/25），计划更新23王道数据结构所有课后代码习题的实现，虽然考试写的一般都是伪代码，但是强迫症的我还是全部实现了一遍，都可以编译运行，包含暴力解和最优解，仓库在这里 https://github.com/mancuoj/wangdao
2024王道数据结构课后习题代码
m0_51057239的博客
03-14 4678
2.1.2 顺序表初始化（动态） 2.1.3 顺序表上插入和删除 2.2综合题 这些题是王道教材的p18-p19的1-14题，2.2.1即为第一题 2.2.2 2.2.3 未完待续… 2023年四月末之前将更新完本书所有习题
2024王道第二章，第一节课后代码题 上（全部实现代码）
qq_53631431的博客
08-31 96
【代码】2024王道第二章，第一节课后代码题 上（全部实现代码）
2024 王道数据结构 代码习题部分 第二章 线性表
weixin_56638583的博客
09-19 363
2024 王道数据结构 代码习题部分 第二章 线性表
2024 王道课后代码题 第二章 单链表（全部实现代码）（上）
qq_53631431的博客
09-11 78
算法思想：建立两个空链表LA，LB，逐步遍历单链表LC奇数部分链接到LA的后面，偶数部分链接到LB的后面，对链表B的部分采用头插法完成逆置，完成LC的拆分。算法思想：将A链表中的奇数部分链接到A链表中，偶数部分链接到B链表中，要保持其相对顺序不变则需要使用尾插法实现算法。算法思想：遍历链表，将链表的值与给定的两个值一一对应，如果处在这两个链表中间则进行链表节点的删除操作。算法思想：遍历单链表，找出最小的值并找到其前驱节点，输出最小值，并释放该节点，时间度为为O（n2)
【2025王道数据结构】王道数据结构课后代码题汇总答案C、C++代码实现完整版大全（可直接运行）
CSDN 精品推荐
04-25 1万+
下面内容是本人在复习王道数据结构的过程中, 对一些算法设计题目的全部实现（答案解析全部都是伪码或者函数的部分实现，不可调试运行），不一定是最优的, 但是都能保证端到端测试运行，本文会陆陆续续更新，个人水平有限，可能文章里面存在一些问题，还望各位多多指点。   加油，阿光！！！我看好你哦😋😋😋 以下摘自王道2023年数据结构考研复习指导题目 文章目录 😉第2章：线性表 ✌18页综合应用题 题号 题解链接 1 传送门 2 传送门 3 传送门 4 传送门 5 传送.
王道数据结构课后选填汇总
02-19
第二章通常涵盖线性结构，特别是数组和链表这两种基本的数据结构。 1. **数组**：数组是最基础的数据结构，它在内存中以连续的方式存储元素。数组的优点是访问速度快，通过索引可以直接访问到任何位置的元素，但...
【专栏必读】王道考研408数据结构+计算机算法设计与分析万字笔记、题目题型总结、注意事项、目录导航和思维导图
热门推荐
快乐江湖的博客
11-23 4万+
各位老铁思维导图在我整理完笔记后会放上去的，我需要根据王道的思维导图重新再做一遍 文章目录一：有关注意事项二：关于专栏三：学习建议四：各专栏导航（各位老铁别催，质量优先）（1）第一章：绪论（2）第二章：线性表（3）第三章：栈和队列第四章：串第五章：二叉树第六章：图 首先感谢王道大大（手动比心），很用心在做了，大家可以看其中两节是否符合胃口 (王道408考研数据结构)第五章树-第三节1：二叉树遍历（先序、中序和后序） (王道408考研数据结构)第五章树-第四节2：平衡二叉树(AVL)及其旋转 一：有.
数据结构之树
x6886_57的博客
11-03 604
树的定义，树的逻辑表示方法，树的基本术语，树的性质，树的存储结构
数据结构---链表实现栈
Dragonlongbo的博客
11-04 251
/用链表作为底层数据结构实现-栈。
插入排序和希尔排序
b123321888的博客
11-04 539
定义：插入排序是一种简单且直观的排序算法，适用于小规模数据的排序。基本思想：通过构建有序序列，对于未排序的数据，在已排序序列中从后向前扫描，找到相应位置并插入。实现特点：使用双层循环，外层循环遍历每个元素，内层循环负责将当前元素插入到正确的位置。定义：希尔排序是一种基于插入排序的排序算法，但它通过将原始列表分割成多个子列表来改进性能，每个子列表使用插入排序进行排序。基本思想：通过比较相距一定间隔的元素来进行排序，逐步减少间隔，直到间隔为1，此时整个列表基本有序，最后进行一次插入排序。
数据结构---链表实现双端队列
Dragonlongbo的博客
11-04 268
/链表实现双端队列。
【数据结构】构造函数和析构函数
cocofu的博客
11-01 757
**构造函数的工作**：在编程中，构造函数的工作就像玩具制造师。每当我们需要一个新的对象，构造函数就会被调用，就像我们需要一个新玩具时，玩具制造师就开始工作。- **析构函数的工作**：在编程中，析构函数的工作就像玩具清理师。- **使用智能指针**：在需要时，建议使用智能指针（如C++中的`std::unique_ptr`和`std::shared_ptr`）来自动管理动态内存，减少手动释放的错误。在我们的程序里，当我们需要一个新的“玩具”时，构造函数就会像玩具制造师一样工作，帮我们准备好一切。
非线性数据结构之图
m0_61840987的博客
11-04 646
无环图 以及 邻接矩阵 和 邻接表 的详细介绍
数据结构的双向链表
w9791028的博客
11-02 268
4、调用函数，按照姓名查找某个学生是否存在，存在输出该学生是第几个节点。1、头插法创建双向链表，节点是学生信息（学号，分数，姓名）3、调用函数，求出分数是完数的学生，并输出该学生所有信息。2、调用函数遍历链表所有信息。
【数据结构-合法括号字符串】【hard】【拼多多面试题】力扣32. 最长有效括号
最新发布
sjsjs11的博客
11-07 135
首先为什么我们要向栈中推入一个-1，实际上这代表着从字符串第0个字符开始计数，然后当发现右括号找不到左括号，也就是栈st为空的时候，就将右括号坐标i填入到栈中，代表着从第i+1个元素开始计数。给你一个只包含 ‘(’ 和 ‘)’ 的字符串，找出最长有效（格式正确且连续）括号子串的长度。栈的大小在最坏情况下会达到 n，因此空间复杂度为 O(n)。，n 是给定字符串的长度。解释：最长有效括号子串是 “()()”解释：最长有效括号子串是 “()”输入：s = “)()())”输入：s = “(()”
Java单/双链表操作详解及实现代码示例
Java 数据结构链表操作实现代码提供了一个深入理解Java链表数据结构的实用指南，包括单链表和双链表的基本概念、实现原理以及它们在编程中的应用。本文首先简要介绍了链表，强调其在数据存储中的高效查询特性，尤其...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值