链表的几个问题

原创 已于 2024-07-28 12:59:40 修改 · 1k 阅读 · 30 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#算法 #数据结构 #链表
于 2024-07-28 12:59:08 首次发布

1.链表的遍历

代码如下：
 

#include<cstdio>

const int MAXN = 100;

struct Node {
	int data, next;
}nodes[MAXN];

int main()
{
	int n, first, id;

	scanf("%d%d", &n, &first);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &id);
		scanf("%d%d", &nodes[id].data, &nodes[id].next);
	}

	int current =first;

	while (current!=-1)
	{
		printf("%d %d %d\n", current, nodes[current].data, nodes[current].next);
		current = nodes[current].next;
	}

	return 0;
}

2.链表结点个数

#include<cstdio>

const int MAXN = 100;

struct Node {
	int data, next;
}nodes[MAXN];

int main()
{
	int n, first, id;

	scanf("%d%d", &n, &first);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &id);
		scanf("%d%d", &nodes[id].data, &nodes[id].next);
	}

	int count=0,current = first;
	while (current != -1) {
		count++;
		current = nodes[current].next;
	}

	printf("%d", count);

	return 0;
}

3.链表头插法

代码如下：

#include<cstdio>

const int MAXN = 1124;

struct Node {
	int data, next;
}nodes[MAXN];

int main()
{
	int n, first, id;

	scanf("%d%d", &n, &first);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &id);
		scanf("%d%d", &nodes[id].data, &nodes[id].next);
	}

	int m;

	scanf("%d", &m);
	for (int i = 0; i < m; i++)
	{
		scanf("%d",&id);
		scanf("%d", &nodes[id].data);
		nodes[id].next = first;
		first = id;
	}

	int current = first;
	while (current!=-1)
	{
		printf("%d %d %d\n", current, nodes[current].data, nodes[current].next);
		current = nodes[current].next;
	}

	return 0;
}

这道题需要注意MAXN大小的设置

4.链表删除元素

代码如下：

#include<cstdio>

const int MAXN = 1124;

struct Node {
	int data, next;
}nodes[MAXN];

int main()
{
	int n, first, k, id;

	scanf("%d%d%d", &n, &first,&k);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &id);
		scanf("%d%d", &nodes[id].data, &nodes[id].next);
	}

	int current = first, last = 0;//last是current序号所在结点的上一个结点的序号

	while (current!=-1)
	{
		if (nodes[current].data == k) {
			if (current == first){//第一个结点特殊性使其需要特别处理
				first = nodes[current].next;
			}
			nodes[last].next = nodes[current].next;//删除结点，将data=k结点a的上一个结点指向a所连接的下一个结点
			current = nodes[last].next;//由于上面last已经连接了下一个结点，故可用这种方法移动current所在结点到下一个结点
		}
		else
		{
			last = current;
			current = nodes[current].next;
		}
	}

	current = first;
	while (current!=-1)
	{
		printf("%d %d %d\n", current, nodes[current].data, nodes[current].next);
		current = nodes[current].next;
	}

	return 0;
}

为了删除结点时链没有“断掉”，故遍历时需要保存上一个结点的序号

另外，注意第一个结点的处理

------------提高题-------------

5.链表反转

代码如下：

#include<cstdio>

const int MAXN = 100;

struct Node {
	int data, next;
}nodes[MAXN];

int main()
{
	int n, first, id;

	scanf("%d%d", &n, &first);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &id);
		scanf("%d%d", &nodes[id].data, &nodes[id].next);
	}

	int current = first, last = -1;

	while (current!=-1)
	{
		int next = nodes[current].next;
		nodes[current].next = last;
		last = current;
		current = next;
	}

	current = last;//此时current=-1，说明last所指向的结点为原链表最后一个结点
	while (current!=-1)
	{
		printf("%d %d %d\n", current, nodes[current].data, nodes[current].next);
		current = nodes[current].next;
	}

	return 0;
}

反转的核心代码如下：

    int current = first, last = -1;//①

    while (current!=-1)
    {
        int next = nodes[current].next;//②
        nodes[current].next = last;//③
        last = current;//④
        current = next;//⑤
    }

接下来我根据①,②,...,⑤这里我画图逐步加以解释：

① int current = first, last = -1;

 

②int next = nodes[current].next; 

 

 ③nodes[current].next = last;

④last = current;

⑤current = next;

总而言之就是把前面的结点按顺序一个接一个放到NULL前面（可能描述得有点不准确）

6.链表删除重复元素

代码如下：

#include<cstdio>

const int MAXN = 100;
const int MAXV = 1000+1;

struct Node {
	int data, next;
}nodes[MAXN];

bool needDelete[MAXV] = { false };
//由于数据域有范围且范围不是很大[1,1000],故可通过数组来标志重复的数据域

int main()
{
	int n, first, id;

	scanf("%d%d", &n, &first);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &id);
		scanf("%d%d", &nodes[id].data, &nodes[id].next);
	}

	int current = first, last = -1;

	while (current!=-1)
	{
		//判断结点数据是否出现过，删除数据重复的结点并移动到下一结点
		if (needDelete[nodes[current].data]) {
			nodes[last].next = nodes[current].next;
			current=nodes[current].next;
		}
		else//如果数据没有出现过，则对该数据进行标记并移动到下一结点
		{
			needDelete[nodes[current].data] = true;
			last = current;
			current = nodes[current].next;
		}
	}

	current = first;
	while (current!=-1)
	{
		printf("%d %d %d\n", current, nodes[current].data, nodes[current].next);
		current = nodes[current].next;
	}

	return 0;
}

关键代码是中间那部分：

	int current = first, last = -1;

	while (current!=-1)
	{
		//判断结点数据是否出现过，删除数据重复的结点并移动到下一结点
		if (needDelete[nodes[current].data]) {
			nodes[last].next = nodes[current].next;
			current=nodes[current].next;
		}
		else//如果数据没有出现过，则对该数据进行标记并移动到下一结点
		{
			needDelete[nodes[current].data] = true;
			last = current;
			current = nodes[current].next;
		}
	}

7.升序链表中位数

方法一：

结合问题2.链表结点个数，判断个数奇偶来得出中位数

代码如下：

#include<cstdio>

const int MAXN = 100;

struct Node {
	int data, next;
}nodes[MAXN];

int main()
{
	int n, first, id;

	scanf("%d%d", &n, &first);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &id);
		scanf("%d%d", &nodes[id].data, &nodes[id].next);
	}

	int count = 0, current = first;
	while (current != -1) {
		count++;
		current = nodes[current].next;
	}

	double result;

	//如果结点个数是偶数，中位数中间两个结点数据域的平均值
	if (count % 2 == 0) {
		int flag = 1;
		current = first;
		while (flag!=count/2)
		{
			flag++;
			current = nodes[current].next;
		}

		result = (nodes[current].data + nodes[nodes[current].next].data) / 2.0;
	}
	else//结点个数是奇数
	{
		int flag = 1;
		current = first;
		while (flag != (count+1) / 2)
		{
			flag++;
			current = nodes[current].next;
		}
		result=(double) nodes[current].data;
	}

	printf("%.1f", result);

	return 0;
}

值得注意的是：

①result = (nodes[current].data + nodes[nodes[current].next].data) / 2.0;

这里除以 2.0，表示进行了浮点数除法。

无论 nodes[current].data 和 nodes[nodes[current].next].data 的类型是什么，整个表达式的结果都将是一个 double 类型的浮点数

②result = (nodes[current].data + nodes[nodes[current].next].data) / 2;

这里除以 2，表示进行了整数除法。

如果 nodes[current].data 和 nodes[nodes[current].next].data 都是整数类型（如 int 或 long），则整数除法会导致结果截断为整数。例如，如果被除数的和是整数 5，整数除以 2 的结果将是 2 而不是 2.5。

由于希望得到一个精确的小数结果，故我们选择①式子

方法二

答案的方法很妙，它设置了两个纸指针：fast和slow。

fast的移动速度是slow的两倍，而且遍历过程总是能保证slow指针所指向的结点始终在first和fast所指向结点的中间，或者是first和fast中间两个结点的前一个结点。

代码如下：

#include<cstdio>

const int MAXN = 100;

struct Node {
	int data, next;
}nodes[MAXN];

int main()
{
	int n, first, id;

	scanf("%d%d", &n, &first);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &id);
		scanf("%d%d", &nodes[id].data, &nodes[id].next);
	}

	int fast = first, slow = first;
	while (nodes[fast].next!=-1&&nodes[nodes[fast].next].next!=-1)
	{
		slow = nodes[slow].next;
		fast = nodes[fast].next;
		fast = nodes[fast].next;
	}

	if (nodes[fast].next = -1) {
		printf("%.1f", (double)nodes[slow].data);
	}
	else
	{
		printf("%.1f", (nodes[slow].data + nodes[nodes[slow].next].data) / 2.0);
	}

	return 0;
}

我们可以画图来理解核心过程：

int fast = first, slow = first;//①
while (nodes[fast].next!=-1&&nodes[nodes[fast].next].next!=-1)
{
    slow = nodes[slow].next;//②
    fast = nodes[fast].next;//③
    fast = nodes[fast].next;//④
}

 当结点个数是偶数时：

这种情况下，最后用以下代码计算中位数：

printf("%.1f", (nodes[slow].data + nodes[nodes[slow].next].data) / 2.0); 

 当结点个数是奇数时：

这种情况下，最后用以下代码计算中位数：

if (nodes[fast].next = -1) {
    printf("%.1f", (double)nodes[slow].data);
}

8.链表倒数第k个结点

代码如下:

#include <cstdio>

const int MAXN = 100;

struct Node {
    int data, next;
} nodes[MAXN];

int main() {
    int n, first, k, id;
    scanf("%d%d%d", &n, &first, &k);
    for (int i = 0; i < n; i++) {
        scanf("%d", &id);
        scanf("%d%d", &nodes[id].data, &nodes[id].next);
    }
    int fast = first;
    while (k--) {
        fast = nodes[fast].next;
    }
    int slow = first;
    while (fast != -1) {
        slow = nodes[slow].next;
        fast = nodes[fast].next;
    }
    printf("%d %d %d", slow, nodes[slow].data, nodes[slow].next);
    return 0;
}

这道题我第一反应是遍历链表得到结点个数n，再用n-k得到倒数第k个结点前的结点个数，再从头遍历；

后面看到了答案的做法感觉好妙,它设置了两个指针，slow在前，fast在后，先让fast比slow多走k个节点，然后slow和fast以相同的速度向前移动，当fast指到NULL时，slow就恰好在第k个结点了。

核心代码如下：

int fast = first;
    while (k--) {
        fast = nodes[fast].next;
    }//①
    int slow = first;//②
    while (fast != -1) {
        slow = nodes[slow].next;
        fast = nodes[fast].next;
    }//③

9.回文链表

方法一：

我第一反应还是先求出链表的结点数，后面觉得自己的方法要进步一些，就参考了7.升序链表中的中位数中的思想，把slow指针遍历过的结点的数据域存储进数组里方便后面进行对比。

但是要注意一种特殊情况，就是只有一个结点的链表是特殊的回文链表。

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<cstdio>

const int MAXN = 100;

struct Node {
	int data, next;
}nodes[MAXN];

int a[MAXN] = { 0 };

int main()
{
	int n, first, id;

	scanf("%d%d", &n, &first);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &id);
		scanf("%d%d", &nodes[id].data, &nodes[id].next);
	}

	int fast = first, slow = first, num=1;
	while (nodes[fast].next!=-1&&nodes[nodes[fast].next].next!=-1)
	{
		a[num] = nodes[slow].data;
		num++;
		slow = nodes[slow].next;
		fast = nodes[fast].next;
		fast = nodes[fast].next;
	}

	bool flag = true;//用来标志链表是否是回文链表
	
	if (num == 1&& nodes[fast].next == -1);//只有一个结点

	else 
	{
		//此时结点个数是奇数,上面的步骤中slow最后位于中点时并没有把中点的数据录入数组中
		if (nodes[fast].next == -1)
		{
			num--;//但鉴于每次录入数据后都会+1，所以这里要把1减掉
			while (num)
			{
				slow = nodes[slow].next;
				if (nodes[slow].data != a[num]) {
					flag = false;
					break;
				}
				num--;
			}
		}

		else//此时结点个数是偶数，则slow可以从下一个结点开始对比遍历
		{
			a[num] = nodes[slow].data;//因为上面的步骤中slow最后位于中点时并没有把中点的数据录入数组中
			while (num)
			{
				slow = nodes[slow].next;
				if (nodes[slow].data != a[num]) {
					flag = false;
					break;
				}
				num--;
			}
		}
	}

	if (flag == true)
		printf("Yes");
	else
		printf("No");

	return 0;
}

方法二：

该方法将输入链表的前1/2进行反转（定位还是用到了7.升序链表中位数的思想），把 5.链表反转 核心代码封装成函数，在这里进行调用。

反转前1/2链表后将两链表结点依次进行对比

#define _CRT_SECURE_NO_WARNINGS
#include<cstdio>

const int MAXN = 100;

struct Node {
	int data, next;
}nodes[MAXN];

//实现链表翻转的函数
int reverseList(int first) {
	int current = first, last = -1;
	while (current!=-1)
	{
		int next = nodes[current].next;
		nodes[current].next = last;
		last = current;
		current = next;
	}

	return last;
}

bool judgePalindrome(int head1, int head2) {
	while (head2 != -1)//由于只对链表前1/2部分进行了翻转，
    //故head2所指向的链表比head1短，因此用head2是否等于 -1 进行判断
	{
		if (nodes[head1].data != nodes[head2].data) {
			return false;
		}
		head1 = nodes[head1].next;
		head2 = nodes[head2].next;
	}
	return true;
}

int main()
{
	int n, first, id;

	scanf("%d%d", &n, &first);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &id);
		scanf("%d%d", &nodes[id].data, &nodes[id].next);
	}

	int fast = first, slow = first;
	while (nodes[fast].next!=-1&&nodes[nodes[fast].next].next!=-1)
	{
		slow = nodes[slow].next;
		fast = nodes[fast].next;
		fast = nodes[fast].next;
	}

	//↑找到链表串前1/2的位置，↓将前1/2链表串反转
	int headOfSecondPart = reverseList(nodes[slow].next);
	bool isPalindrome = judgePalindrome(first, headOfSecondPart);
	
	printf(isPalindrome ? "Yes" : "No");

	return 0;
}

c++链表的创建与遍历——代码详细注释版
yh_secret的博客
03-02 1220
本人是一名刚开始学习算法的小白，今天学习了链表的创建与遍历，方便以后复习，也为自学党提供一些学习思路，望大神多多指教！2023/3/2
P3 链表的遍历详解，新手也能一眼会
weixin_73901182的博客
12-01 2102
🎬 个人主页：@ChenPi🐻推荐专栏1: 《》✨✨✨🔥 推荐专栏2: 《》✨✨✨📝推荐专栏3: ​​​​​​《》 ✨✨✨🍉本篇简介 : 使用代码的形式演示链表与数组的区别✨ 只有我努力了 才有机会接触成功✨链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。
链表的遍历与输出
2302_79330691的博客
03-24 700
【代码】链表的遍历与输出。
链表（四）遍历链表
m0_60977861的博客
03-17 8090
从链表头开始，涉及整个链表，在每个结点上操作的过程称为遍历链表 假设链表的链表头指针是namelist，要遍历链表，则需要另一个指针ptr指向链表的开头。 listnode* ptr = head; 然后可以使用表达式*ptr或者结构指针操作符->处理由ptr指向的结点。 需要打印节点上的值 cout << ptr->name << endl; 一旦该节点打印完毕，那么指针将会移动到下一个节点 ptr = ptr -> next1; 以上语句
C++ 链表遍历
weixin_46585382的博客
06-09 2272
C++ 链表遍历
链表中的几个问题以及特殊链表
LCH的博客
07-02 516
                        链表中的几个问题以及特殊链表*****判断两个单链表是否相交，如果相交，给出相交的第一个点（两个链表都不存在环）。比较好的方法有两个：一、将其中一个链表首尾相连，检测另外一个链表是否存在环，如果存在，则两个链表相交，而检测出来的依赖环入口即为相交的第一个点。二、如果两个链表相交，那个两个链表从相交点到链表结束都是相同的节点，我们可以先遍历一个链表，直...
链表的几个基础问题
有趣的人
03-28 279
*链表的管理 *出圈问题 *约瑟夫环问题（变种） *用插入法建立有序链表 *链表中节点的查找与定位 链表的管理 #include&lt;iostream&gt; using namespace std; struct node { int data; node *next; };//node node *head=NULL; void showList(){...
链表的几个经典问题
07-13 534
下面是几个关于链表的非常经典的问题与实现，是在《程序员面试攻略》中看到的，由于实在是太经典了，所以忍不住在这里贴下。       问题1：给定一个单项链表，设计一个时间优化并且时间优化的算法，找出该链表的倒数第m个元素。当m=0时，返回链表的最后一个元素。     [分析：用双指针来实现，两指针间隔m。同步移动两指针，当前一个指针为该链表tail时，后一个指针就为要找的元素] El
单链表有环的几个问题
wanlong1215的博客
12-02 347
转自：https://www.cnblogs.com/dancingrain/p/3405197.html 给定一个单链表，判断其中是否有环，已经是一个比较老同时也是比较经典的问题，在网上搜集了一些资料， 然后总结一下大概可以涉及到的问题，以及相应的解法。 首先，关于单链表中的环，一般涉及到一下问题： 1.给一个单链表，判断其中是否有环的存在； 2.如果存在环，找出环的入口点； 3.如果存在环，求出环上节点的个数； 4.如果存在环，求出链表的长度； 5.如果存在环，求出环上距离任意一个.
链表中关于环的几个小问题
hale1007的专栏
03-28 703
参考很多资料，也做了点题目，在这里小汇总一下。有不到位的地方，恳请指出，谢谢！ 描述： 给定一个链表头指针为head，针对这个链表有如下问题： 1、如何判断这个链表有没有环？ 2、环的长度如何计算？ 3、怎么找到环开始的地方？ 解决思路： 1、两种思路，第一种：用一个map保存节点的地址，从前往后扫，如果某个节点的地址出现了两次，则说明有环。这种思路实现起来也很快，但
解题笔记（13）——几个链表的问题
wuzhekai的专栏
07-25 4667
问题1：输入一个链表的头结点，反转该链表，并返回反转后链表的头结点。问题2：输入一个链表的头结点，从尾到头反过来输出每个结点的值。问题3：给定链表的头指针和一个结点指针，在O(1)时间删除该结点。问题4：两个单向链表，找出它们的第一个公共结点。
C++链表几个问题
weixin_42636062的博客
07-04 133
创建链表 //利用链表创建三个学生的信息，学生信息包括姓名和年龄，输出名为kaka学生的年龄 #include<iostream> using namespace std; //第一步，创建结构体 struct student { char name[20]; int age; student *next; //第二步，在节点数据中添加一个指针节点数据类型的指针next }; int main() { // 链表创建 student c = { "Terry",30,NU.
带环链表得几个问题
Linkin_ygw的博客
01-21 911
1、判断一个链表是否有环，如果有环，则返回入环的第一个节点，否则返回null 如果一个链表有环，遍历一个链表便永远不会到达null，否则必定会到达null。设置两个指针，刚开始都指向头节点，遍历时，一个指针每次前进一步，我们称之为慢指针，另一个每次前进两步，称之为快指针，这样，如果链表没有环，快指针必然会到达null，如果有环，两个指针必然会相交于一点。 下面再来看看如何找到入环的第一
几个链表相关问题
CSUjavaGzy的专栏
05-04 193
  一、约瑟夫环问题 已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。例如：n = 9,k = 1,m = 5       主要思路：构建一个list，将n个人放入list中，规定开始位置k，开始遍历，每执行m次，将当前元素移除lis...
关于单链表的几个问题
weixin_30429201的博客
06-18 149
Q:如何判断一个单链表是否有环，如果有环，找出环的入口点？ A:首先我们判断链表是否有环，设置两个指针slow和fast，指向单链表的头部，每个循环slow走一步，fast走两步。如果没有环，fast或者fast的next会走到NULL，否则fast在环里循环最终会和slow相遇，此时即存在环。 再看第二个问题，当slow和fast相遇时，假设fast已经在环内循环n圈，环长为r，同时fa...
关于单链表的几个有意思的问题
iclinux的专栏
04-29 927
Q1:已知指向单链表的header指针，如何判断该单链表是否存在环？Q2:已知两个单链表，它们可能存在重叠的部分，也就是Y字形链表，如何判断这两个链表是否存在Y字形？Q3:已知指向单链表的header指针，如何高效的输出单链表的倒数第n个节点？(最后一个节点为倒数第0个节点)Q4:不知道单链表的header指针，仅仅知道指向某节点的指针p，如何在链表中删除该节点？ 答案在后面
牛客网：链表倒数几个节点的问题
weixin_46266058的博客
05-20 265
链表 快慢指针
单链表关于环的几个问题
betonme的博客
11-08 229
问题： 1.单链表是否有环 2.环的节点长度 3.环的入口节点 4.表头到环入口的节点长度 问题1.思路: 在表头设置fast、slow指针，fast一次遍历两个节点，slow一次遍历一个节点，若相遇则证明有环，反之则不存在环 代码： /** *引入快慢指针，若指针相遇则证明链表有环 */ Node * findRing(Node *head) { Node * fast...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值