关于链表的基础题目

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

一.题目一览

二.问题及改进

三.总结

1.题目一：建立一个链表，每个结点包括：学号，姓名，性别，年龄。输入一个年龄，如果节点所包含的年龄等于此年龄，将此结点删去。

这是我第一次写的丑陋 的代码

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef struct student
{
long num;
char name[20];
char sex[2];
int age;
struct student* next;
}student, * Student;

//创建链表(包含了初始化）
student* creat()
{
student *s,*head=NULL; //*s 新创建的结点
int n = 0;
student r; //r 尾指针
s = r=(student)malloc(sizeof(student));
printf(“请输入：\n”);
scanf(“%ld%s%s%d”, &s->num, s->name, &s->sex, &s->age);
while (s->num != 0) //改进？
{
n = n + 1;
if (n == 1) head = s; //？
else r->next = s; //原来的结点指向新结点
r = s;
s = (student)malloc(sizeof(student));
scanf(“%ld%s%s%s”, &s->num, s->name, &s->sex, &s->age);
}
r->next = NULL;
return head;
}

student* search(student* head, int x)
{
student* p; //循环所用的临时指针
p = head;
while (p != NULL) //判断头指针指向的链表有结点，否则为空
{
if (p->age == x)
return p;
p = p->next;
}
return NULL;
}

student* del(student* head, int x)
{
student* s,* r;
if (head == NULL) //空链表
{
printf(“null\n”);
return NULL;
}
s = head; //s用来找到要删除的结点 从首结点开始
while (s->age != x && s->next != NULL) //
{
s = s->next; //向后遍历
r=s; //记录当前结点的位置
}
if (s->age == x)
{
if (s == head) //首结点
head = s->next; //删除此结点 头指针向后移 释放此空间
else r->next = s->next; //r也跟着往后移
free(s);
}
else printf(“no find\n”);
return head;
}

void print(student* head)
{
student* p;
p = head;
while (p != NULL)
{
printf(" % ld % s % s % d", p->num, p->name, p->sex, p->age);
p = p->next;
}
}

int main()
{
student* head;
head = creat();
print(head);
int x;
scanf(“%d”, &x);
do
{
head = del(head, x);
} while (search(head, x) != NULL);
print(head);
return 0;
}

大家会发现有明显的漏洞：
没有头结点 导致在进行链表的查找 删除 等等都非常麻烦!

所以我写了一个带头结点的链表
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef struct student
{
long num;
char name[100];
char sex[100];
int age;
struct student* next;
} LNode, *LinkList;

//创建链表(包含了初始化）
LinkList creat()
{
LinkList H = (LinkList)malloc(sizeof(LNode));
H -> next = NULL; //创建头结点
LNode *r = H;
LinkList s = (LinkList)malloc(sizeof(LNode));

while(1)
{
scanf(“%ld%s%s%d”,&s->num,s->name,s->sex,&s->age);
if(s->num==-1)
{
free(s);
break;
}
r->next=s;
r=s;
s=(LNode*)malloc(sizeof(LNode));
}
r->next=NULL;
return H;
}

void del(LinkList H, int x)
{
LinkList p,q; //p指向第i-1的位置 q指向i的位置
p=q=(LNode*)malloc(sizeof(LNode));
p=H;
int j=0;
while(j<x-1&&p)
{
p=p->next;
j++;
}
if(pNULL||p->nextNULL)
printf(“结点不存在！\n”);
else
{
q=p->next;
p->next=q->next;
free(q);
}
}

void print(LinkList H)
{
LNode* p;
p = H->next;
while §
{
printf(" % ld % s % s % d\n", p->num, p->name, p->sex, p->age);
p = p->next;
}
}
int main()
{
printf(“请输入学号、姓名、性别、年龄\n”);
LinkList H = creat();
print(H);
printf(“请输入要删除的年龄\n”); //按值删除
int x;
scanf(“%d”, &x);
del(H,x);
print(H);
return 0;
}

可是！有没有发现这个是按位置查找并删除的！我们需要的是按值查找！修改del函数如下：

void del(LinkList H,int x)
{
LinkList t,p=H->next,pre=H;
while§
{
while(p&&p->age!=x)
{
p=p->next;
pre=pre->next;
}
t=p;
pre->next=p->next;
free(t);
p=pre;
}
}

看起来没有问题，可是实际运行不出来！问题就出在结点删除后free后面的p=pre！因为p位置的结点已经释放了，那么p要是再跟着pre走，p->next即pre->next,这时p实际应该指向的下一个结点已经没有了，只靠pre输出了…所以不可以！那么为了每次删除成功并继续向后找，可以
1 .预存p->next结点，防止丢失
2 .每次删除后，p直接从删除后的下一个结点开始再寻找（更推荐）
3.注意！p走p的，pre走pre的，两个指针不要相互赋值！

改进如下
t=p;
pre->next=p->next;
free(t);
//p=pre; //错误的！因为释放掉t 即p后 pre的next结点已经丢了！
p=pre->next;

运行成功！！！泪目

整体代码如下

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef struct student
{
	long num;
	char name[100];
	char sex[100];
	int age;
	struct student* next; 
} LNode, *LinkList;
//创建链表(包含了初始化） 
LinkList creat()
{
	LinkList H = (LinkList)malloc(sizeof(LNode));  
	H -> next = NULL;  //创建头结点
	LNode *r = H;
	LinkList s = (LinkList)malloc(sizeof(LNode));

	while(1)
	{
		scanf("%ld%s%s%d",&s->num,s->name,s->sex,&s->age);
		if(s->num==-1)
		{
			free(s);
			break;
		}
		r->next=s;
		r=s;
		s=(LNode*)malloc(sizeof(LNode));
	}
	r->next=NULL;
	return H;
}

void del(LinkList H,int x)
{
	LinkList t,p=H->next,pre=H;
	while(p)
	{
	   while(p&&p->age!=x)
	   {
		p=p->next;
		pre=pre->next;
	   }
	   t=p;
	   pre->next=p->next;
	   free(t);
	   //p=pre;   //错误的！因为释放掉t 即p后 pre的next结点已经丢了！
	   p=pre->next; 
    }
}
void print(LinkList H)
{
	LNode* p;
	p = H->next;
	while (p)
	{
		printf(" % ld % s % s % d\n", p->num, p->name, p->sex, p->age);
		p = p->next;
	}
}
int main()
{
	printf("请输入学号、姓名、性别、年龄\n");
	LinkList H = creat();
	print(H);
	printf("请输入要删除的年龄\n");     //按值删除 
	int x;
	scanf("%d", &x);
	del(H,x);
	print(H);
	return 0;
}

2.建立两个单链表a,b,从a中删除在b中存在的结点。

第一次失败的代码

LinkList1 creat1()
{
LinkList1 H1=(LNode1*)malloc(sizeof(LNode1));
H1->next=NULL;
LinkList1 r=H1，s=(LNode1*)malloc(sizeof(LNod));
while(s->a!=-1){
s=(LNode1*)malloc(sizeof(LNode1));
s->next=r->next;
r=s;
scanf(“%d”,&s->a);}
r->next=NULL;
}
return H1;

我们会发现这样输入数据后，-1也会被输入，这不是我们想要的结果。改！！

while(1)
{
scanf(“%d”, &(s->a));
if (s->a == -1)
{
free(s); //防止把-1写进链表里
break;
}
r->next = s;
r = s;
s = (LNode*)malloc(sizeof(LNode));
}

这样其实稍微有一点点麻烦，因为对于数据域只有数字的结点，我们可以直接判断输入的数字，而不用对s->data判断。

LinkList creat()
{
LinkList H=(LNode*)malloc(sizeof(LNode));
H->next=NULL;
LinkList r = H,s;
int a;
scanf(“%d”,&a);
while(a!=-1)
{
s=(LNode*)malloc(sizeof(LNode));
s->a=a;
r->next=s;
r=s;
scanf(“%d”,&a);
}
r->next=NULL;
return H;
}

然后删除的部分和第一道题目差不多，改动的是需要建立两个结构体指针，分别对a,b的结点寻找，记得free后让p,pre分别指向它们的下一个结点！

整体代码如下：

#include<stdio.h>
#include<malloc.h>
typedef struct data
{
	int a;
	struct data *next;
}LNode,*LinkList;
LinkList creat()
{
	LinkList H=(LNode*)malloc(sizeof(LNode));
	H->next=NULL;
	LinkList r = H,s;
    int a;
    scanf("%d",&a);
    while(a!=-1)
    {
    	s=(LNode*)malloc(sizeof(LNode));
    	s->a=a;
    	r->next=s;
    	r=s;
    	scanf("%d",&a);
	}
	r->next=NULL;
	return H;
}
void print(LinkList H)
{
	LinkList p=H->next;
	while(p)
	{
		printf("%d ",p->a);
		p=p->next;
	}
	printf("\n");
}
void del(LinkList H1,LinkList H2)
{
	LinkList t,p=H1->next,pre=H1;
	LinkList q=H2;
	while(p)
	{
		q=H2->next;     //q每次从首结点开始找 
		while(q)
		{
		  if(p->a==q->a)
	      {
	    	t=p;        //p就是要删的结点 
	    	pre->next=p->next;
	    	p=pre->next;           //因为可能有多组重复要删的结点 所以p一直往后走 而每次删完后从删的后一个开始走 
	    	free(t);         //最好最后再释放 防止结点丢失 
		  }
		  q=q->next;
	    }
	    pre=pre->next;         //pre p 都往后找 
	    p=p->next;    //寻找p的下一个结点是否需要删去 
	}
}
int main()
{
	LinkList H1=creat();
	LinkList H2=creat();
	//print1(H1);
	//print1(H2);
	del(H1,H2);
	print(H1);
	return 0;
}

3.删除链表中相同元素的结点。

  • 已排序的链表
void del(LinkList H)
{
	LNode *p,*q,*t,*pre;
	p=H->next;
	q=p;
	while(p)
	{
	   q=p->next;        //p是q的前驱 
	   while(q)
	   {
		 if(p->data==q->data)
		 {
		 	t=q;
			p->next=q->next;
			free(t);
			q=q->next;
		 } 
		 else  
		 {
		    p=q;         //因为已经排序了，所以直接两两相比即可 
		    q=q->next;
		 }   
	}
}
  • 未排序的链表
void del(LinkList H)
{
	LNode *p,*q,*s;
	p=H;
	s=p;        //s用来第n次遍历时的在while(q)内部代替p向后移动 不能在里面移动头指针p p是在最外面控制遍历次数的 
	while(p)    //将第n个结点和它之后的所有结点比较是否相同 遍历n次 
	{
		q=p->next;  //q存p的下一个结点 
		while(q)
		{
			if(p->data==q->data)
			{
				s->next=q->next;
				free(q);
				q=s->next; 
			}
			else
			{
				s=q;     //相当于s往后移动 因为q一直在移动 
				q=q->next;
			}
		}
		p=p->next;
	}
 }

（注意：要用另一个变量控制每一趟遍历时内部的指针的移动）

4.删除链表中值大于x小于y的元素

void del(LinkList *H,int x,int y)
{
	LinkList *p,*q,*pre;
    pre=H;
	p=H->next;
	while(p&&p->data<y)
	{
		if(p->data<=x)     //继续向后找 
		{
			//pre=pre->next;   也可以 
			pre=p;         //pre要先被赋值 然后p指向下一个结点 这时达到了pre是p前一个结点的效果 
			p=p->next;
		}
		else
		{
			pre->next=p->next;
			q=p;     //q是个中间结点 负责释放空间 
			free(q);
			p=p->next;
		}
	}
}

只要掌握删除节点的方法即可

5.合并两个有序的单链表

#include<stdio.h>
#include<malloc.h>
typedef struct s
{
	int x;
	struct s* next;
}s,*LinkList;

void merge(LinkList HA,LinkList HB)
{
	LinkList HC;
	LinkList *p,*q,*r;
	p=HA->next;
	q=HB->next;
	r=HC=HA;
	while(p&&q)
	{
		if(p->x<=q->next)
		{
			r->next=p;
			r=p;
			p=p->next;
		}
		else
		{
			r->next=q;
			r=q;
			q=q->next;
		}
	}
	if(p)  r->next=p;
	if(q)  r->next=q;
	free(HB);          //将结果保存在HA中 
}

6.n个人，围成圈，按1-n报号，号码是m的人退出，如此往复，直到剩最后一个人。

#include<stdio.h>
#include<malloc.h>
typedef struct node
{
	int data;
	struct node* next;
}node,*LinkList;
int baoshu(int m)
{
	int i;
	LinkList H,r,p,s;
	H=(LinkList)malloc(sizeof(node));
	//H->next=H;
	H->data=1;   //不可以为空！因为循环链表 万一指向了头结点的数据域 就为随机值了 
	r=H; 
	for(i=2;i<=m;i++)
	{
		s=(LinkList)malloc(sizeof(node));
		s->data=i;
		r->next=s;
		r=s;
	 } 
	 r->next=H;    //尾结点指向头结点
	 p=r->next;   //p是找到的要删的   r是p的前驱结点
	 int k=1;     //报数
	 while(m>1)
	 {
	 	if(k!=3)
	 	{
	 		k++;
	 		r=p;     //遍历 
			p=p->next; 
		 }
		 else
		 {
		 	k=1;
		 	m--;
		 	r->next=p->next;
		 	free(p);
		 	p=r->next;   //p从删除的结点的下一个开始找 
		 }
	  } 
	  return (r->data);    //r始终指向被删结点的前驱结点 故只剩下最后一人 r就指向这个人 
}
int main()
{
	int n;
	scanf("%d",&n);
	printf("%d",baoshu(n));
	return 0;
}

需要注意的就是头结点也要放数据，不然可能最后到了这个随机值。

总结！

删除一个结点时，（我的方法）需要引入一个指针，负责free，需要引入前驱指针，它和一直遍历的指针相互配合。

t=p；
pre->next=p->next；
p=p->next;
free(t);

我认为free最后再写更保险一些
总之就是，p和pre各走各的就行，这样可以保证链表不断，总是能找到下一个结点。

祝我们都能早日拿下链表！
在这里插入图片描述

头头本头-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
从链表a中找出与链表b相同的值并删除！
追
12-06 4660
算法:其实这和直接删除a链表中的某个节点类似，只是现在不是在删除一个节点，而是要与b链表先进行比较后再进行删除。首先先选取a中的第一个节点，从b中第一个开始找，找不到的话b就继续后移，b移到结尾还是未找到就说明b中任何一个没有与a中第一个节点相同，则a向后移动，以此类推。当有找到相同的节点时，情况1.此时a链表指向头结点，则只需要让头结点指向下一结点。情况2.不是头结点时只需要让a的前一个节点（p
链表基础与题目分析
qq_40043345的博客
12-10 521
链表基础知识
链表基础题目
不屈土豆的博客
11-15 328
探究链表特性及基础问题。
链表基础练习（C语言实现）
小何代码咖啡馆
02-21 935
回文链表，本质即为以中间节点为对称轴，如果中间节点的左右部分完全相等，则证明该链表为回文链表，根据这个特点，可以考虑思路：因为回文链表以中间节点为对称轴，所以先找到中间节点，因为中间节点的左右部分完全相等，所以将中间节点的后部分链表反转再与原链表的节点中的val进行比较，如果相等即为回文链表，不相等则不为回文链表。带头双向链表优化了四个指针为空的问题，为四个指针单独开辟两个空间作为头结点，遇到大于或者等于x的尾插到大链表的头结点处，遇到小于x的尾插到小链表的头节点处，此时不需要单独处理第一个节点。
关于C语言链表基础知识
Bill_Hao的博客
02-16 7468
链表和数组作为算法中的两个基本数据结构，在程序设计过程中经常用到。尽管两种结构都可以用来存储一系列的数据，但又各有各的特点。数组的优势，在于可以方便的遍历查找需要的数据。在查询数组指定位置（如查询数组中的第4个数据）的操作中，只需要进行1次操作即可，时间复杂度为O(1)。但是，这种时间上的便利性，是因为数组在...
链表基础算法思想及常见leetcode题目
m0_55356312的博客
04-24 242
链表基础算法思想 1. 双指针（快慢指针） 2. 头插、尾插与逆序 3. 链表环问题
链表基础知识总结
热门推荐
u012531536的专栏
05-02 17万+
链表和数组作为算法中的两个基本数据结构，在程序设计过程中经常用到。尽管两种结构都可以用来存储一系列的数据，但又各有各的特点。数组的优势，在于可以方便的遍历查找需要的数据。在查询数组指定位置（如查询数组中的第4个数据）的操作中，只需要进行1次操作即可，时间复杂度为O(1)。但是，这种时间上的便利性，是因为数组在内存中占用了连续的空间，在进行类似的查找或者遍历时，本质是指针在内存中的定向偏移。然而，当...
链表经典题目
qq_33253721的博客
05-19 507
一、虚拟头结点 题目203. 移除链表元素. 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 在链表中想要删除一个节点，让节点（待删除节点的上一个节点）的next指针指向下下个节点即可（node.next = node.next.next）。 除了正常的删除，我们还需要考虑特殊的情况，比如，删除的是头节点该怎么办？ 第一种方式：直接使用原来的链表进行删除操作 即将头节点向后移动一位即可 然后再将原本的头节点删
链表LeetCode题目总结C++
zzzz_yu的博客
12-26 643
链表的数据结构较为简单，一个链表一般有其元素值和指向下一个节点的指针组成，借助leetcode上的定义为：
链表 | 链表基础
weifengomg的博客
12-10 1750
链表基础
单链表-数据结构
qq_31804097的博客
08-07 110
【代码】单链表、双向带头循环链表-数据结构。
数据结构初阶：栈和队列
LCL200356的博客
08-03 858
栈的结构的定义和顺序表结构定义一样，在栈中定义一个指针data用于操作数据，然后定义整型变量capacity用于表示栈的空间大小，最后定义一个整型变量top用于表示有效数据个数也就是我们的栈顶。//定义一个栈的结构//数组//栈的空间的大小int top;//有效数据个数}ST;队列的结点结构就是单链表结点结构，队列结构phead指向头结点和ptail指向尾结点，还有一个size用同统计结点个数。//链式结构表示队列}QNode;//队列结构int size;//计数器。
算法回忆录（2）
m0_73399576的博客
08-05 1178
算法回忆录（2）
【数据结构-前缀哈希】力扣525. 连续数组
最新发布
sjsjs11的博客
08-07 94
将nums中的0全部替换成-1，然后定义一个哈希表group，键用来储存sum，值用来储存对应的前缀和的下标。当前计算前缀和sum的时候，如果前面有相同的前缀和，说明中间这个子段和为0，也就说明0和1的数量相等，所以这个时候。给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。来求这个子段的长度。
[C++进阶&数据结构]二叉搜索树
2301_80017277的博客
08-07 847
对于二叉树的结点，我们类似于list的结点定义一样，使用一个struct类。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 292
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
从零开始学数据结构系列之第四章《迪杰斯特拉算法了解》
铁匠匠匠的博客
08-04 1095
1、先选定一个根结点，并选定一个数组，先确定未遍历前的初始距离，把距离最短的邻接结点选定为中间结点，并标记访问过，开始往下遍历，挨个访问那个中间结点的邻接结点。计算出根结点到中间结点+中间结点到新邻接结点的距离，作为新距离，对比新距离和旧距离，如果新距离大，则把新距离替换掉旧距离，否则不变。算法的基本思想是：从源点出发，每次选择离源点最近的一个顶点前进，然后以该顶点为中心进行扩展，最终得到源点到其余所有点的最短路径。2、一轮访问结束后，从未标记的结点中选定距离最短的，把它作为中间结点，继续往下访问。
数据结构 | 考研代码题之顺序表 | 1 查找L中值为e的数据元素若找到则返回其下标，若找不到则返回-1
猫天意的博客
08-04 205
假设有一个顺序表 L，其存储的所有数据元素均为不重复的正数，查找L中值为e的数据元素，若找到则返回其下标，若找不到则返回-1。
数据结构图书管理系统
2305_78057683的博客
08-07 164
数据结构图书管理系统
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值