链表面试题总结

最新推荐文章于 2022-08-07 10:22:51 发布
最新推荐文章于 2022-08-07 10:22:51 发布
阅读量1.2k 收藏 16
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hansionz/article/details/81608860
版权

链表面试题总结

一.定义数据结构

typedef int DataType;

typedef struct Node
{
    DataType data;
    struct Node * next;
}Node,*pNode,LinkList,*pLinkList;

二.各题目函数声明

//从尾到头打印链表
void PrintLinkTailToHead(pLinkList pl);

//删除一个无头单链表的非尾结点
void RmoveNodeNotTail(pLinkList *ppl, pNode pos);

//用链表实现约瑟夫环
void JosephCircle(pLinkList *ppl, int sz);

//在无头单链表的一个节点前插入一个节点(不能遍历链表)
void InsertNodeNotHead(pLinkList *ppl, DataType data, pNode pos)

//链表的逆置
void Reverselist(pLinkList *ppl);

//链表的冒泡排序
void BubbleSort(pLinkList *ppl);

//合并两个有序的链表，合并后依然有序
pNode Merge(pLinkList list1, pLinkList list2);

//合并两个有序的链表(递归版本)
pNode Merge_R(pLinkList list1, pLinkList list2);

//求单链表中间结点
pNode FindMidNode(pLinkList plist);

//求单链表倒数第K个结点
pNode FindLastKNode(pLinkList plist, int k);

//判断链表是否带环，带环返回相遇点，不带环返回NULL
pNode IsCircle(pLinkList plist);

//求环的长度
int GetCircleLength(pNode meet);

//求环的入口点
pNode GetCircleEntryNode(pLinkList plist, pNode meet);

//判断链表是否相交(假设链表不带环)，相交返回1，不想交返回0
int IsCross(pLinkList plist1, pLinkList plist2);

//求两个链表的交点
pNode GetMeetNode(pLinkList plist1, pLinkList plist2);

//求两个链表中相同的数据(交集)
void UnionSet(pLinkList plist1, pLinkList plist2);

三.函数实现

（1）.从尾到头打印链表(题目来源：剑指offer)

https://blog.csdn.net/hansionz/article/details/80905962

void PrintLinkTailToHead(pLinkList pl,stack * s)
{
//（1）
#if 0
	if(pl != NULL)
	{
		if(pl->next != NULL)
		{
			PrintLinkTailToHead(pl->next);
		}
		printf("%d--->",pl->data);
	}
	/*if (pl == NULL)
	{
		return NULL;
	}
	PrintLinkTailToHead(pl->next);
	printf("%d--->", pl->data);*/
#endif
//(2)
#if 0
	pNode tail = NULL;
	while (pl != tail)
	{
		pNode cur = pl;
		while (cur->next != tail)
		{
			cur = cur->next;
		}
		printf("%d--->", cur->data);
		tail = cur;
	}
#endif
//(3)
	Node* cur = pl;
	while (cur != NULL)
	{
		s->data[s->top++] = cur->data;
		cur = cur->next;
	}
	while (s->top >= 0)
	{
		printf("%d--->", s->data[s->top--]);
	}
	printf("over\n");
}

（2）.删除一个无头单链表的非尾结点（不能遍历链表）(题目来源：剑指offer)

思路：要删除一个结点，就必须找到要删除结点的前驱。但是不能遍历链表，我们找不到前驱。我们试着改变一下思路，将要删除结点的下一个结点的数据复制给要删除的结点，而要删除的结点就变成了原来要删除结点的下一个结点。这样就很巧妙的删除了结点。
https://blog.csdn.net/hansionz/article/details/80934410

void RmoveNodeNotTail(pLinkList *ppl, pNode pos)
{
	pNode del = NULL;
	assert(ppl != NULL);
	assert(pos->next != NULL);
	assert(*ppl != NULL);
	pos->data = pos->next->data;//复制数据
	del = pos->next;//改变要删除的结点
	pos->next = del->next;//删除下一个结点
	free(del);
	del = NULL;
}

（3）.用单链表实现约瑟夫环问题

https://blog.csdn.net/hansionz/article/details/81539863

void JosephCircle(pLinkList *ppl, int k)
{
	assert(ppl != NULL);
	pNode cur = *ppl;
	pNode tmp = *ppl;
	pNode del = NULL;
	//将单链表连成一个换
	while (tmp->next)
	{
		tmp = tmp->next;
	}
	tmp->next = *ppl;
	//如果还有大于1个结点则继续查找
	while (cur != cur->next)
	{
		int count = k;
		//走k-1步，清除一个
		while (--count)
		{
			cur = cur->next;
		}
		//删除当前结点
		del = cur->next;
		printf("删除：%d\n", cur->data);
		cur->data = cur->next->data;
		cur->next = del->next;
		free(del);
		del = NULL;
	}
	printf("剩余：%d\n", cur->data);
}

（4）.在无头单链表的一个节点前插入一个节点(不能遍历链表)

思路：既然不能遍历链表，说明找不到前驱，那我们只能先将这个结点插入到它的后边，然后在交换数据。或者，在开辟结点的时候就已前面结点的数据开辟，插入之后再将前面结点的数据域设置为已知数据，从而达到交换的效果。

void InsertNodeNotHead(pLinkList *ppl, DataType data, pNode pos)
{
	pNode newNode = NULL;
	assert(ppl != NULL);
	//（1）
#if 0
	DataType tmp = 0;
	newNode = BuyNode(data);
	newNode->next = pos->next;
	pos->next = newNode;
	tmp = newNode->data;
	newNode->data = pos->data;
	pos->data = tmp;
#endif
	//（2）
	newNode = BuyNode(pos->data);
	newNode->next = pos->next;
	pos->next = newNode;
	pos->data = data;
}

（5）.链表的逆置/反转

思路：重新开辟一条链表，然后依次取下原链表的每个结点头插入到新的链表中，新的链表就是逆置的结果

void Reverselist(pLinkList *ppl)
{
	pNode cur = *ppl;
	pNode tmp = NULL;
	pLinkList head = NULL;
	assert(ppl != NULL);
	if (*ppl == NULL || (*ppl)->next == NULL)
	{
		return;
	}
	while (cur)
	{
		tmp = cur->next;//保存下一个结点，否则会丢失链表后边的内容
		cur->next = head;
		head = cur;
		cur = tmp;
	}
	*ppl = head;
}

单独总结于另一边博客：
https://blog.csdn.net/hansionz/article/details/82285384

（6）.链表的冒泡排序

void BubbleSort(pLinkList *ppl)
{
	assert(ppl != NULL);
	pNode cur = *ppl;
	pNode tail = NULL;
	while (cur != tail)//确定躺数
	{
		while (cur->next != tail) //确定比较次数
		{
			if (cur->data > cur->next->data)
			{
				DataType tmp = cur->data;
				cur->data = cur->next->data;
				cur->next->data = tmp;
			}
			cur = cur->next;
		}
		tail = cur;
		cur = *ppl;
	}
}

（7）.合并两个有序的链表，合并后依然有序

pNode Merge(pLinkList list1, pLinkList list2)
{
	pLinkList newhead = NULL;
	//一个链表为空，另一个不为空
	if (list1 == NULL)
	{
		return list2;
	}
	if (list2 == NULL)
	{
		return list1;
	}
	//两个链表都为空
	if ((list1 == NULL) && (list2 == NULL))
	{
		return NULL;
	}
	//无头结点的单链表，必须先插入一个结点才能将以后的结点操作统一
	if (list1->data < list2->data)
	{
		newhead = list1;
		list1 = list1->next;
	}
	else
	{
		newhead = list2;
		list2 = list2->next;
	}
	//保存链表最后一个结点的位置
	pNode tail = newhead;
	//依次比较尾插
	while ((list1 != NULL) && (list2 != NULL))
	{
		if (list1->data < list2->data)
		{
			tail->next = list1;
			list1 = list1->next;
		}
		else
		{
			tail->next = list2;
			list2 = list2->next;
		}
		tail = tail->next;
	}
	//将剩余的结点插入到新链表中
	if (list1 == NULL)
	{
		tail->next = list2;
	}
	else if (list2 == NULL)
	{
		tail->next = list1;
	}
	return newhead;
}

（8）.合并两个有序的链表，合并后依然有序(递归版本)

pNode Merge_R(pLinkList list1, pLinkList list2)
{
	pLinkList newhead = NULL;
	if (list1 == NULL)
	{
		return list2;
	}
	if (list2 == NULL)
	{
		return list1;
	}
	if ((list1 == NULL) && (list2 == NULL))
	{
		return NULL;
	}
	if (list1->data < list2->data)
	{
		newhead = list1;
		newhead->next = Merge_R(list1->next, list2);
	}
	else
	{
		newhead = list2;
		newhead->next = Merge_R(list1, list2->next);
	}
	return newhead;
}

（9）.求单链表中间结点

思路：利用快慢指针思想，快指针fast每次走两步，满指针slow每次走一步。当快指针做到最后一个结点时，慢指针正好指向中间结点。

pNode FindMidNode(pLinkList plist)
{
	pNode slow = plist;
	pNode fast = plist;
	//链表没有结点或者只有一个结点直接返回
	if ((plist == NULL) || (plist->next == NULL))
	{
		return plist;
	}
	//节点数为偶数时判断条件为fast!=NULL,此时中间节点为后面的那个;
	//为奇数时判断条件为fast->next!=NULL.
	while ((fast != NULL) && (fast->next != NULL))
	{
		fast = fast->next->next;
		slow = slow->next;
	}
	return slow;
}

（10）.求单链表倒数第K个结点

思路：依然是利用快慢指针的方法，让快指针先走k-1步，然后快指针和慢指针一起出发，当快指针走到最后一个结点时，慢指针指向倒数第k个结点。

pNode FindLastKNode(pLinkList plist, int k)
{
	pNode fast = plist;
	pNode slow = plist;
	if (plist == NULL)
	{
		return plist;
	}
	//快指针走k-1步
	while (--k)
	{
		//如果链表总的节点数小于k,则肯定不存在倒数第k个结点
		if (fast == NULL)
		{
			return NULL;
		}
		fast = fast->next;
	}
	//快慢指针一起走，快的到终点，慢指针则指向倒数第k个结点
	while (fast->next != NULL)
	{
		fast = fast->next;
		slow = slow->next;
	}
	return slow;
}

（11）.判断单链表是否带环，带环返回相遇点，不带环返回NULL

思路：依旧是快慢指针的思想，快指针一次走两步，慢指针一次走一步，如果单链表带环，则快指针和慢指针必然相遇。

//带环返回相遇点，不带环返回NULL
pNode IsCircle(pLinkList plist)
{
	pNode fast = plist;
	pNode slow = plist;
	if (plist == NULL)
		return NULL;
	while ((fast != NULL) && (fast->next != NULL))
	{
		fast = fast->next->next;
		slow = slow->next;
		if (fast == slow)
		{
			return fast;
		}
	}
	return NULL;
}

（12）.求单链表中环的长度

思路：从相遇点的下一个结点开始便利一遍环，就可以求出来环的长度了。但是len必须是从1开始，否则会少计算相遇点那个结点。

int GetCircleLength(pNode meet)
{
	assert(meet != NULL);
	pNode cur = meet->next;
	int len = 1;
	//len必须从1开始，否则没有算meet那个结点
	while (cur != meet)
	{
		len++;
		cur = cur->next;
	}
	return len;
}

（13）.求单链表中求环的入口点

思路：
在这里插入图片描述

pNode GetCircleEntryNode(pLinkList plist, pNode meet)
{
	pNode cur = plist;
	if (plist == NULL)
	{
		return NULL;
	}
	assert(meet != NULL);
	while (cur != meet)
	{
		cur = cur->next;
		meet = meet->next;
	}
	return cur;
}

（14）.判断链表是否相交(假设链表不带环)，相交返回1，不想交返回0

这里写图片描述
思路:两条不带环的链表相交最后一个结点必然相同。

int IsCross(pLinkList plist1, pLinkList plist2)
{
	pNode end1 = plist1;
	pNode end2 = plist2;
	if ((plist1 == NULL) || (plist2 == NULL))
	{
		return 0;
	}
	//确定链表一的尾结点
	while (end1->next != NULL)
	{
		end1 = end1->next;
	}
	//确定链表二的尾结点
	while (end2->next != NULL)
	{
		end2 = end2->next;
	}
	return end1 == end2;
}

（15）.求两个不带环单链表的交点

这里写图片描述

pNode GetMeetNode(pLinkList plist1, pLinkList plist2)
{
	int len1 = 0;
	int len2 = 0;
	int gap = 0;
	pNode cur1 = plist1;
	pNode cur2 = plist2;
	//求链表1长度
	while (cur1)
	{
		len1++;
		cur1 = cur1->next;
	}
	//求链表2长度
	while (cur2)
	{
		len2++;
		cur2 = cur2->next;
	}
	//求差值
	gap = abs(len1 - len2);

	cur1 = plist1;//长
	cur2 = plist2;//短
	if (len1 < len2)
	{
		cur1 = plist2;
		cur2 = plist1;
	}
	//长链表走gap步
	while (gap--)
	{
		cur1 = cur1->next;
	}
	//一起走
	while (cur1!=cur2)
	{
		cur1 = cur1->next;
		cur2 = cur2->next;
	}
	return cur1;
}

（16）.求两个已排序链表中相同的数据(交集)

void UnionSet(pLinkList plist1, pLinkList plist2)
{
	if ((plist1 == NULL) || (plist2 == NULL))
	{
		return;
	}
	while ((plist1 != NULL) && (plist2 != NULL))
	{
		if (plist1->data < plist2->data)
		{
			plist1 = plist1->next;
		}
		else if (plist1->data > plist2->data)
		{
			plist2 = plist2->next;
		}
		else
		{
			printf("%d ", plist1->data);
			plist1 = plist1->next;
			plist2 = plist2->next;
		}
	}
}
Hansionz
关注
专栏目录
Python面试宝典第4题：环形链表
hope_wisdom的技术博客
07-03 992
给你一个链表的头节点 head ，判断链表中是否有环。如果存在环 ，则返回 true 。 否则，返回 false 。
链表面试题总结 C/C++
Dev-L的博客
11-02 2245
数据结构和算法，是我们程序设计最重要的两大元素，可以说，我们的编程，都是在选择和设计合适的数据结构来存放数据，然后再用合适的算法来处理这些数据。       在面试中，最经常被提及的就是链表，因为它简单，但又因为需要对指针进行操作，凡是涉及到指针的，都需要我们具有良好的编程基础才能确保代码没有任何错误。       链表是一种动态的数据结构，因为在创建链表时，我们不需要知道链表的长度，
链表面试题总结（一）
热门推荐
宇哲
06-11 1万+
基于上一次写的链表，现在，我们来讨论下面这些问题。1.链表的冒泡排序 2.删除无头非尾节点 3.反转链表 4.在当前节点前插入一个数据x 5.查找链表的中间节点。 6.删除单链表的倒数第K个节点（K>1&&K<总长度）对于上面这6个问题，我们进行分析与解答。链表的代码我都已经写过博客：数据结构—单链表的实现另外，我也在我的github上有链表的代码，github链接如还有什么问题，可以发邮
链表面试题
tian_wen的专栏
11-03 846
某本书上面说了，链表这个东西，实际用的并不多，但是可以提供很好的考察面试者编程技巧和思维能力的素材。这里总结一下，见过的面试题和对应的候选解法。 题一、给定单链表，检测是否有环。 使用两个指针p1,p2从链表头开始遍历，p1每次前进一步，p2每次前进两步。如果p2到达链表尾部，说明无环，否则p1、p2必然会在某个时刻相遇(p1==p2)，从而检测到链表中有环。 http://ostermil
面试题-链表
coder_xia的专栏
08-30 1010
如何准备 Linked list questions are extremely common These can range from simple (delete a node ina linked list) to much more challenging Either way, we advise you to be extremely comfortable with the eas
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 6733
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
链表面试习题总结（二）
weixin_44024891的博客
06-11 239
七、删除链表中重复的结点 – 牛客网 题目链接 描述： 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5 分析： 这道题可以借鉴之前删除指定值结点题目。 我们需要三个指针prev，cur，next。 根据我画图上内容。 1、cur、next指针负责判断是否出现重复结点。 而且先删除next重复结点， 因为还可能存在重复， 因此cur
常见的链表面试题大汇总
09-05
常见的链表面试题大汇总： 1，创建一个链表结点 2，遍历链表中的所有结点 3，倒序打印链表 4，往链表末尾添加结点 5，往链表前端添加结点, 6，获取链表的节点数目 7，销毁链表 8，求链表中倒数第K个节点 9，反转链表 10，查找链表中间节点 11，判断链表是否有环 12，判断链表是否有环，并返回环上的节点数目
链表面试题目总结 全
09-05
链表是最基本的数据结构，凡是学计算机的必须的掌握的，在面试的时候经常被问到，关于链表的实现，百度一下就知道了。 在此总结一下与链表相关的练习题。题目很全，好好消化。
链表面试题（一）
tt 博客
05-30 1468
1.反转一个单链表。 public class MySingleLinkedlmpl { class Node{ public int getData() { return data; } private int data; public Node next; public Node(i...
【数据结构】链表面试题总结(持续更新中...)
weixin_44258092的博客
08-07 348
总结归纳链表常见面试题。
链表相关面试题
Damn_Yang的博客
11-08 485
链表的基本操作在链接的博客中已经有实现https://blog.csdn.net/Damn_Yang/article/details/83689944 下面我们来看看链表相关的面试题，非常重要 下面的题目都会一个一个实现 #include&lt;stdio.h&gt; typedef int DataType; typedef struct Node { DataType data; ...
链表面试题总结：查找、合并、判定循环链表
链表面试题总结 链表是一种基本的数据结构，它在编程中有着广泛的应用。链表的面试题涵盖了链表的基本操作、链表的遍历、链表的排序、链表的反转等方面。在本文中，我们将对链表面试题进行总结，并提供相应的知识...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值