寻找两个相交链表的第一个公共节点

最新推荐文章于 2025-03-23 20:19:03 发布
原创 最新推荐文章于 2025-03-23 20:19:03 发布 · 1.1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#交叉链表

本文探讨了两个链表相交点的寻找方法及单向链表中环的判断和环入口确定的问题，提供了三种不同的算法解决方案及其C++实现。

Q：已知有两个链表，他们可能相交于某一点，求出该点。

方法1. 最简单的方法就是先顺序访问其中一个链表，在每访问一个节点时，都对另外一个链表进行遍历，看节点是否相等

  直到找到一个相等的节点位置，如果链表长度分别是m,n 则时间复杂度为O(mn)；


方法2. 对于第一个链表，每访问一个节点，对该节点做标记。访问第二个链表，如果该元素已经访问，则第一个这样的元素就是所求点。

由于两个链表都访问了一遍，因此时间复杂度O(m+n),空间复杂度O(m)或O(n)；


方法3. 如果两个单向链表有公共的结点，也就是说两个链表从某一结点开始，它们的m_pNext都指向同一个结点。但由于是单向链表的结点，每个结点只有一个m_pNext，因此从第一个公共结点开始，之后它们所有结点都是重合的，不可能再出现分叉。所以，两个有公共结点而部分重合的链表，拓扑形状看起来像一个Y，而不可能像X。

如果两个链表的总长度是相等的，那么我们对两个链表进行遍历，则一定同时到达第一个公共节点。但是链表的长度实际上不一定相同，所以我们只需要计算出两个链表的长度之差n，然后让长的那个链表先移动n步，短的链表再开始向后遍历，这样他们一定同时到达第一个公共节点，我们只需要在向后移动的时候比较两个链表的节点是否相等就可以获得第一个公共节点。时间复杂度是O(m+n)。

基于这个思路，我们不难写出如下的代码：

template<typename T>
struct ListNode
{
	T data;
	ListNode* pNext;
};
template<typename T> int GetListLength(ListNode<T>* pHead)
{
	int nLength = 0;
	while(pHead)
	{
		++nLength;
		pHead = pHead->pNext;
	}
	return nLength;
}
template<typename T>
ListNode<T>* FindFirstCommonNode(ListNode<T>* pHead1, ListNode<T>* pHead2)
{
	int nLength1 = GetListLength(pHead1);
	int nLength2 = GetListLength(pHead2);

	// 交换两链表，是1为较长的链表
	if(nLength1 < nLength2)
	{
		ListNode<T>* pTemp = pHead1;
		pHead1 = pHead2;
		pHead2 = pTemp;
	}
	for(int i = 0; i < nLength1 - nLength2; ++i)
	{
		pHead1 = pHead1->pNext;
	}
	while(pHead1 && pHead1 != pHead2)
	{
		pHead1 = pHead1->pNext;
		pHead2 = pHead2->pNext;
	}

	return pHead1;
}

上题是基于两个链表无环考虑的。

1）判断一个链表是否有环。

设置两个指针(fast, slow)，初始值都指向头，slow每次前进一步，fast每次前进二步，如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。(当然，fast先行头到尾部为NULL，则为无环链表)

// 判断链表是否有环
template<typename T>
bool HasRing(ListNode<T>* pHead)
{
	ListNode<T>* pFast = pHead;
	ListNode<T>* pSlow = pHead;
	while(pFast && pFast->pNext)
	{
		pSlow = pSlow->pNext;
		pFast = pFast->pNext->pNext;

		if(pSlow == pFast) break;
	}

	return !pFast && !pFast->pNext;
}

2）确定环入口：

当fast若与slow相遇时，slow肯定没有走遍历完链表，而fast已经在环内循环了n圈(1<=n)。

假设slow走了s步，则fast走了2s步（fast步数还等于s 加上在环上多转的n圈），设环长为r，则：

2s = s + nr
s= nr

设入口环与相遇点距离为x，x<r，起点到环入口点的距离为a.

a = s - x = (n-1)r+ (r-x), 而r-x即为fast再次到环入口点时的步数

由此可知，从链表头到环入口点等于(n-1)循环内环+相遇点到环入口点，于是我们从链表头、与相遇点分别设一个指针，每次各走一步，两个指针必定相遇，且相遇第一点为环入口点。

// 判断链表环入口，如果没有环，返回NULL
template<typename T>
ListNode* FindRingEntrance(ListNode<T>* pHead)
{
	ListNode<T>* pFast = pHead;
	ListNode<T>* pSlow = pHead;

	// 先找到相遇点
	while(pFast && pFast->pNext)
	{
		pSlow = pSlow->pNext;
		pFast = pFast->pNext->pNext;
		if(pSlow == pFast) break;
	}

	// 一个从起点，一个从相遇点重新遍历，步长相同，当再次相遇时，就是环入口
	pSlow = pHead;
	while(pFast && pFast != pSlow)
	{
		pSlow = pSlow->pNext;
		pFast = pFast->pNext;
	}

	return pFast;
}

算法题5 找出两个链表的第一个公共结点
在水一方
05-17 2万+
题目：两个单向链表，找出它们的第一个公共结点。 链表的结点定义为： struct ListNode {       int       m_nKey;       ListNode*   m_pNext; }; 分析：这是一道微软的面试题。微软非常喜欢与链表相关的题目，因此在微软的面试题中，链表出现的概率相当高。 如果两个单向链表有公共的结点，也就是说两个链表从某一结点开始，它们的
寻找相交链表的公共节点（C语言）
weixin_44788162的博客
10-24 646
声明：题目来源：力扣（LeetCode） 输入两个链表，找出它们的第一个公共结点。 题目链接：相交链表 编写一个程序，找到两个单链表相交的起始节点。 示例1： 在节点 c1 开始相交。 示例2： 两链表不相交，返回NULL。 解题思路： 首先需要判断两个链表长度是否相等，使用两个指针分别以相等的速度遍历两个链表，判断哪个链表长，并计算出差值 d。 再使用两个指针同时从表头出发，指向长链表的指...
算法：求两个单链表相交的第一个节点
Yufail的博客
03-06 1430
判断两个单链表是否相交以及相交的情况下求第一个相交节点，两个链表可以有环，也可以无环。因此我们可以从以下几个步骤分析： 判断一个单链表是否存在环路，如果无环，返回null，反之，返回入环节点。 如果两个单链表均无环，进入相应的子程序，如果无相交，返回null，反之，返回第一个相交节点。 如果一个有环，一个无环，进入相应的子程序，如果无相交，返回null，反之，返回第一个相交节点。 如果两个单链表...
两个链表的第一个公共节点
nwpulei
10-29 6702
已知有两个链表，他们可能相交于某一点，求出该点。 方法1.对于第一个链表，每访问一个节点，对该节点做标记。访问第二个链表，如果该元素已经访问，则第一个这样的元素就是所求点。 由于两个链表都访问了一遍，因此时间复杂度O(m+n),空间复杂度O(m)或O(n) 方法2.我们定义节点的距离为节点到链表开始所经过的节点数。如果两个链表长度相同，则相交节点其在两个链表上的距离一定相等。对于长度不同的两
两个单向链表的第一个公共节点
weixin_34037977的博客
09-23 217
参考 http://blog.163.com/clevertanglei900@126/blog/static/1113522592011914148467/ 问题： 两个单向链表，可能存在公共节点。如何判断是否存在公共节点，并找出它们的第一个公共结点。思想： 1. 如果两个链表相交，则从相交点开始，后面的节点都相同，即最后一个节点肯定相同；2. 从头到尾遍历两个链表，并记录链表长度，当二...
五种方法解决两个链表第一个公共子节点
纵横千里 捭阖四方 的专栏
12-11 745
这是一道经典的链表问题先看一下题目。 输入两个链表，找出它们的第一个公共节点。 例如下面的两个链表： 两个链表的头结点都是已知的，相交之后成为一个单链表，但是相交的位置未知，并且相交之前的结点数也是未知的，请设计算法找到两个链表的合并点。 1.没有思路时该怎么解题 这种问题该怎么入手呢？如果一时想不到该怎么办呢？其实这时候我们可以将常用数据结构和常用算法都想一遍，看看哪些能解决问题。 常用的数据结构有数组、链表、队、栈、Hash、集合、树、堆。常用的算法思想有查找、排序、双指针、递归、迭.
精选资源
[剑指-Offer] 52. 两个链表的第一个公共节点(思维、快慢指针、巧妙解法）
01-08
在编程面试中，经常会出现涉及到链表操作的问题，其中寻找两个链表的第一个公共节点是一个经典题目。这道题目最初的来源是LeetCode上的《剑指 Offer》专项，其中编号为52。此题不仅考察面试者对链表结构的理解，更...
判断两个链表是否相交
程序猿老樊的博客
03-23 833
判断两个链表是否相交，指的是判断两个单链表是否存在至少一个公共节点。如果存在公共节点，那么从这个公共节点开始，两个链表后续的所有节点都是相同的，因为单链表的每个节点只有一个指向下一个节点的指针。如果遍历到链表末尾都没有找到相同的节点，则说明两个链表不相交。可以通过遍历两个链表，找到它们的长度，然后让较长的链表先走差值步，使得两个链表剩余的长度相同，再同时遍历两个链表，判断是否有相同的节点。如果两个链表相交，那么从相交节点开始，它们的后续节点是完全相同的。也就是说，相交节点及其之后的节点在内存中是共享的。
算法题(单链表：查找两个相交链表的第一个相交节点)
Colorful_X的博客
05-06 446
查找两个相交链表的第一个相交节点。 题目：       查找两个相交链表的第一个相交节点。给出两个链表，找出它们的第一个公共节点。 思路：       使用双指针。       ① 定义一个快指针记作fast。让它指向长链表。定义一个慢指针记作slow，让它指向短链表。      
两个单向链表的第一个公共结点
怪咖小青年的博客
08-01 902
leetcode160：相交链表 题目： 编写一个程序，找到两个单链表相交的起始节点 实例： A: a1 → a2 ↘ c1 → c2 → c3 ↗ B: b1 → b2 → b3 思路： 因为链表是单向链表，所...
【数据结构】单链表—寻找两个相交链表中第一个公共结点 — 蛮力法 / 栈 / 指针先走
liuxiaoqian_的专栏
07-26 746
题目：输入两个链表，找到它们的第一个公共结点。思路一：蛮力法 在第一个链表上顺序遍历每一个结点，每遍历一个节点在第二个链表顺序遍历每一个结点，如果第二个链表上有一个结点和第一个链表上一样，说明两个链表在这个结点上重合，于是就找到它们的公共结点。len1 = m,len2 = n,时间复杂度为O(mn)。思路二：栈 分别把两个链表的结点放入两个栈里，这样两个链表的尾结点就位于两个栈的栈顶，接下来就
第六十二题（求两个单向链表的第一个公共节点）
06-25 1153
62.找出链表的第一个公共结点。 题目：两个单向链表，找出它们的第一个公共结点。 链表的结点定义为： struct ListNode { int m_nKey; ListNode* m_pNext; };
两个链表的第一个公共节点（相交链表），剑指offer,力扣
m0_70437378的博客
11-24 660
4、如果两个链表中没有公共的结点，那PA和PB都将会遍历到链表的尾部，链表的尾部为null，那么PA、PB也会相等，但返回的是null。若相交，链表A: a+c, 链表B : b+c. 那么a+c+b+c = b+c+a+c ,则会在公共处c起点相遇。2、PA遍历链表A，当遍历到链表A尾部时，将headB头指针赋值给PA，PA开始遍历链表B，PB同理；今天刷两个链表的第一个公共节点（相交链表），大家有兴趣可以点上看看题目要求，试着做一下。假设a,b分别为两链表A,B非公共部分，c为公共部分。
两条相交的单向链表，如何求他们的第一个公共节点
iemsadw的博客
02-21 188
数据结构
两个链表相交，要求找出第一个相交的节点
cs_zhangyi的博客
08-27 1118
《编程之美》里面有一篇是讲如何判断两链表是否相交，读后觉得原文太过啰嗦。于是，笔者总结了一下，此类问题可以扩展为两大类，分别是： 1、单链表与环问题http://blog.youkuaiyun.com/liuxialong/archive/2011/06/20/6555850.aspx 2、单链表相交与环问题（本文） 给定两单链表A、B，只给出两头指针。请问： 1、如何判断两单链表（无环）是否相交？
寻找两个相交的单链表的第一个节点
qq_31964815的博客
03-24 1021
两个相交的单链表的第一个节点 昨天，58集团笔试，我在上面看到了一道比较常见的笔试题。就是两个相交的单链表的第一个节点。 首先，我们应该考虑清楚单链表相交的情况。单链表有些特殊。两个单链表相交一定只会有一种情况，这是我们必须知道的。这种情况就是下图。   这就是单链表的特殊点了。那看着这个图我们应该就很清楚这个题目的做法了。我们首先算出两个链表的长度。然后我们让长链表首先遍历这个差值。
两个单向链表，找出它们的第一个公共结点。
nciaebupt
07-10 1501
/* copyright@nciaebupt 转载请注明出处 题目：两个单向链表，找出它们的第一个公共结点。 链表的结点定义为： struct ListNode { int m_n Key ; ListNode * m_pNe xt ; }; 分析：这是一道微软的面试题。微软非常喜欢与链表相关的题目，因此在微软的面试题中，链表出现的概
[互联网面试笔试汇总C/C++-8] 寻找两个链表的第一个交点-微策略
844604778
10-10 161
题目：有两个链表，找出他们的第一个交点，要求每个链表只能遍历一次，可以对链表进行任何操作，空间O(1). 思路： 这个题目刚开始看觉得要遍历一次有点困难，但是仔细一想，人家告诉说可以对链表进行任何操作，这是一个没有用到的条件（大家一定要注意到题目中没有用到的条件，往往是解题的关键所在）。 于是乎，方法如下： 1.遍历第一个链表List1，将每一个节点的next都置为NULL。 2.遍...
剑指Offer52-两个链表的第一个公共节点
哆啦A瑶的博客
02-21 458
剑指Offer典型题整理 - 争取做最好的题解 整理时间：2020年02月21日 本题和 LeetCode 160题相同 1 题目描述 输入两个链表，找出它们的第一个公共节点。 注意 如果两个链表没有交点，返回 null. 在返回结果后，两个链表仍须保持原有的结构。 可假定整个链表结构中没有循环。 程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。 2 题解 链表题最适合画图分析了~ ...
检测两个链表是否相交
最新发布
10-28
<think>首先，用户的问题是：“检测两个链表是否相交的算法”。用户提供了几个引用，我需要基于这些构建回答。用户说“参考站内引用”，所以我应该引用这些来源。 用户提供的引用： - [^1]: 解释链表相交的定义。 - [^2]: 左神算法，涉及链表是否有环、两无环链表是否相交等。提到了计算长度差的方法。 - [^3]: 通过比较尾结点来判断是否相交。 - [^4]: 类似[^2]，提到了计算长度差的方法。 用户强调：“上述引用仅供参考，并不是用户真正的需求，请尽可能多的参考用户上一次的问题和你的回答。” 但在这个对话中，这是第一次用户的问题，所以我应该专注于当前问题。系统指令说“回答中引用的段落末尾自然地添加引用标识”，所以我必须在回答中引用这些来源。 系统级指令： - 所有行内数学表达式使用$...$格式。 - 独立公式使用$$...$$格式。 - LaTeX语法正确。 - 使用中文回答。 - 生成相关问题。 - 回答结构清晰，逐步解决问题。 用户的问题是关于检测两个链表是否相交的算法。我需要提供一个清晰的、逐步的解释。 关键点从引用中： - 判断两个单链表是否相交：检查是否有公共节点。 - 方法1（从[^3]）：比较尾结点。如果尾结点相同，则相交；否则，不相交。 - 方法2（从[^2]和[^4]）：计算链表长度差，移动长链表的指针到相同起始点，然后同步遍历比较节点。 此外，[^2]提到了链表是否有环的问题，但用户的问题似乎专注于无环链表，因为引用[^1]说“单链表”，假设无环。我应该确认是否是单链表无环的情况。 用户说“检测两个链表是否相交”，没有指定是否有环。引用[^2]提到了有环和无环的情况。但为了简单，我应该先从无环链表开始。 步骤： 1. 确认链表类型：假设是单链表，可能无环或有环。 2. 对于无环链表： - 方法A（尾结点比较）：如果两个链表的尾结点相同，则相交；否则，不相交。 - 方法B（长度差）：计算两个链表的长度差，移动长链表的头指针到相同位置，然后同步遍历直到找到相同节点或结束。 3. 如果有环，情况更复杂，需要先判断是否有环。 但用户的问题可能针对简单情况。我应该从基础开始。 回答结构： - 简介：解释什么是链表相交。 - 算法描述：逐步解释检测方法。 - 代码示例：提供伪代码或编程语言代码。 - 相关问题：生成相关问题。 使用中文回答。 生成相关问题在最后。 现在，算法描述： 1. **尾结点比较法**（简单有效）： - 遍历链表1到尾部，保存尾结点。 - 遍历链表2到尾部，保存尾结点。 - 比较两个尾结点：如果相同，则链表相交；否则，不相交。 - 时间复杂度：O(n+m)，其中n和m是链表长度。 - 空间复杂度：O(1)，只需存储尾结点。 2. **长度差法**（可以找到相交点）： - 计算链表1的长度len1和尾结点。 - 计算链表2的长度len2和尾结点。 - 如果尾结点不同，则不相交；否则，相交。 - 然后，为了找到相交点：计算长度差diff = |len1 - len2|。 - 让长链表的指针先移动diff步。 - 然后两个指针同步移动，直到找到相同节点。 - 时间复杂度：O(n+m)。 - 空间复杂度：O(1)。 尾结点比较法可以判断是否相交，但不能直接找到相交点。长度差法可以判断并找到相交点。 用户的问题是“检测是否相交”，所以尾结点比较法可能足够。 从效率上，两者都高效。 现在，代码示例：我应该提供伪代码或具体语言代码。用户引用中提到C++和Java，所以我可以选择一个通用语言或伪代码。 生成相关问题：如“如何找到相交点？”，“如果链表有环怎么办？”等。 添加引用：在相关段落末尾添加引用标识。 数学表达式：链表问题通常不需要数学，但如果有公式，比如长度差，可以使用行内格式。 例如：计算长度差diff = |len1 - len2|，写成行内数学：$diff = |len1 - len2|$。 独立公式可能不需要。 回答结构： - 问题背景 - 方法1：尾结点比较（引用[^3]） - 方法2：长度差法（引用[^2]和[^4]） - 其他情况（如有环） - 总结 - 代码示例 - 相关问题 其他情况：链表可能有环，引用[^2]讨论了有环链表相交的问题。我应该简要提及。 但保持焦点在用户需求上：检测是否相交。 </think>### 检测两个链表是否相交的算法 在计算机科学中，判断两个链表是否相交是一个常见的问题，特别是在链表操作中（如链表合并、循环检测等）。链表相交指的是两个单链表是否存在至少一个公共节点。如果存在公共节点，那么从这个节点开始，后续所有节点都是相同的，因为单链表的每个节点只有一个指向下一个节点的指针[^1]。下面我将逐步解释检测算法，确保结构清晰、可靠。算法主要针对无环单链表（最常见情况），最后会简要讨论有环链表的情况。时间复杂度通常为$O(n + m)$（其中$n$和$m$是链表长度），空间复杂度为$O(1)$。 #### 核心算法：无环链表检测 对于无环单链表，有两种高效算法可以检测是否相交。两种方法都基于一个关键原理：如果链表相交，它们必有相同的尾结点（即链表末尾节点）。因此，判断尾结点是否相等是基础步骤。以下是详细步骤： 1. **尾结点比较法（简单高效，仅判断是否相交）** 这种方法通过比较两个链表的尾结点来直接判断是否相交。如果尾结点相同，则链表相交；否则，不相交。算法步骤如下： - 遍历链表1，找到尾结点（即最后一个节点）。 - 遍历链表2，找到尾结点。 - 比较两个尾结点： - 如果尾结点相同（内存地址相等），则链表相交（因为相交链表共享相同的尾部）。 - 如果尾结点不同，则链表不相交。 - 时间复杂度：$O(n + m)$（每个链表遍历一次）。 - 空间复杂度：$O(1)$（仅需存储尾结点指针）。 - 优点：实现简单，代码易读。 - 缺点：只能判断是否相交，无法直接找到相交点（首个公共节点）。 - 伪代码示例（基于引用[^3]）： ```java // 辅助函数：找到链表的尾结点 Node findEnd(Node head) { if (head == null) return null; Node current = head; while (current.next != null) { current = current.next; } return current; } // 检测是否相交 boolean isIntersect(Node head1, Node head2) { Node end1 = findEnd(head1); // 找到链表1的尾结点 Node end2 = findEnd(head2); // 找到链表2的尾结点 return end1 == end2; // 比较尾结点是否相同 } ``` 2. **长度差法（可同时判断相交和找到相交点）** 这种方法在尾结点比较基础上，额外计算链表长度差，从而不仅能判断是否相交，还能找到相交点。算法步骤如下： - 遍历链表1，计算长度$len1$并保存尾结点。 - 遍历链表2，计算长度$len2$并保存尾结点。 - 比较尾结点： - 如果尾结点不同，则链表不相交（直接返回失败）。 - 如果尾结点相同，则链表相交（继续下一步）。 - 计算长度差：$diff = |len1 - len2|$。 - 移动长链表的头指针$diff$步（例如，如果$len1 > len2$，将链表1的指针移动$diff$步）。 - 同步遍历两个链表：每次移动两个链表的指针各一步。 - 当指针指向同一个节点时，该节点就是首个相交点。 - 如果遍历到末尾（null）仍未找到相同节点，则无相交（理论上不会发生，因为尾结点相同已确保相交）。 - 时间复杂度：$O(n + m)$（遍历长度和同步遍历各一次）。 - 空间复杂度：$O(1)$（只需存储长度和指针）。 - 优点：可找到相交点，适用于需要定位的场景。 - 缺点：代码稍复杂。 - 伪代码示例（基于引用[^2]和[^4]）： ```java // 辅助函数：计算链表长度和尾结点 int[] getLengthAndEnd(Node head) { if (head == null) return new int[]{0, null}; int len = 1; Node current = head; while (current.next != null) { current = current.next; len++; } return new int[]{len, current}; // 返回长度和尾结点 } // 检测是否相交（返回相交点或null） Node findIntersection(Node head1, Node head2) { // 获取链表1的长度和尾结点 int[] info1 = getLengthAndEnd(head1); int len1 = info1[0]; Node end1 = info1[1]; // 获取链表2的长度和尾结点 int[] info2 = getLengthAndEnd(head2); int len2 = info2[0]; Node end2 = info2[1]; // 比较尾结点：如果不同，则不相交 if (end1 != end2) { return null; } // 计算长度差，移动长链表的指针 Node p1 = head1; Node p2 = head2; int diff = Math.abs(len1 - len2); if (len1 > len2) { for (int i = 0; i < diff; i++) { p1 = p1.next; } } else if (len2 > len1) { for (int i = 0; i < diff; i++) { p2 = p2.next; } } // 同步遍历直到找到相交点 while (p1 != p2) { p1 = p1.next; p2 = p2.next; } return p1; // p1 和 p2 相等时即为相交点 } ``` #### 其他情况：有环链表的处理 如果链表可能含有环（即节点指向自身或先前节点），
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值