单向链表相交的第一个公共结点, 判断链表是否有环以及环的入口节点

最新推荐文章于 2023-11-06 17:54:06 发布
最新推荐文章于 2023-11-06 17:54:06 发布
阅读量745 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 面试题目 c/c++ 文章标签： 单向链表相交的第一个公共结点 判断链表是否有环以及环的入口节点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/small_small_chick/article/details/9081155
本文介绍了一种算法，用于查找两个单向链表的第一个公共节点。通过计算链表长度并调整遍历起点，确保同时到达交点，还探讨了如何检测链表中的环及其入口节点。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

//////题目：两个单向链表，找出它们的第一个公共结点。
//////
//////链表的结点定义为：
//////
//////struct ListNode
//////
//////{
//////
//////      int       m_nKey;
//////
//////      ListNode*   m_pNext;
//////
//////};
//////
//////分析：这是一道微软的面试题。微软非常喜欢与链表相关的题目，因此在微软的面试题中，链表出现的概率相当高。
//////如果两个单向链表有公共的结点，也就是说两个链表从某一结点开始，它们的m_pNext都指向同一个结点。
//////但由于是单向链表的结点，每个结点只有一个m_pNext，因此从第一个公共结点开始，
//////之后它们所有结点都是重合的，不可能再出现分叉。所以，两个有公共结点而部分重合的链表，
//////拓扑形状看起来像一个Y，而不可能像X。

#include <iostream>
#include <algorithm>
using namespace std;

#define NSIZ 101

struct ListNode 
{ 

	int m_nKey; 
	ListNode*  m_pNext; 

}; 

//获得链表长度
int GetListLength(ListNode * head)
{
	if(!head)
	{
		return 0;
	}
	int len = 0;
	ListNode * tmp = head;

	while(tmp)
	{
		++len;
		tmp = tmp->m_pNext;
	}
	return len;
}

//尾插法构造链表
void CreateList(ListNode * & head, int arr[], int n)
{
	ListNode * p = head;
	if(head == 0)
	{
		head = new ListNode();
		head->m_nKey = arr[0];
		p = head;
	}
	int i = 1;
	for(;i < n; ++i)
	{
		ListNode * tmp = new ListNode();
		tmp->m_nKey = arr[i];
		p->m_pNext = tmp;
		p = tmp;
	}
	p->m_pNext = 0;
}

//合并2个链表
ListNode* UnionList(ListNode * head1, ListNode * head2)
{

	if(head1 == 0 && head2)
	{
		return head2;
	}
	else if(head1 && !head2)
	{
		return head1;
	}
	else if(head1 && head2)
	{
		ListNode * pre = head1;
		ListNode * p = pre->m_pNext;
		while(p)
		{
			pre = p;
			p = p->m_pNext;
		}

		pre->m_pNext = head2;
		return head1;
	}
	else
	{
		return 0;
	}
}

//打印链表元素值
void dump(ListNode * head)
{
	ListNode * p = head;
	while(p)
	{
		printf("%d ", p->m_nKey);
		p = p->m_pNext;
	}

	printf("\n");
}

//判断两个链表是否有交点，如果有则返回第一个交点
//如果head1 && head1 == head2那么显然相交，返回head1
//否则 分别获得head1链表和head2链表的长度为len1和len2 ，并且假设len1 > len2
//然后用指针pLong从head1开始向后移sub = len1 - len2步，指针pShort = head2
//然后p1,p2每次前进一步并且比较p1 == p2，若不为空且相等则返回p1，
//否则说明head1链表和head2链表没有交点
ListNode * FirstCommonNode(ListNode * head1, ListNode * head2)
{
	int len1 = GetListLength(head1);
	int len2 = GetListLength(head2);
	ListNode * Short = head1, *Long = head2;
	int sub = len2 - len1;
	if (len1  > len2)
	{
		Short = head2;
		Long = head1;
		sub  = len1 - len2;
	}

	while(sub > 0)
	{
		Long = Long->m_pNext;
		--sub;
	}

	while(Short && Long && Short != Long)
	{
		Short = Short->m_pNext;
		Long = Long->m_pNext;
	}

	if (Short && Long && Short == Long)
	{
		return Short;
	}

	return 0;
}

//检测链表中是否有环,快慢指针方法
//若有环则返回从头结点进入环的第一个节点
//假设p1 = head1, p2 = head->next->next
//首先检查是否有环，有环的话p1，p2必然在环内相遇
//此时从相遇处端口，方法为
//common = p2;
//head2 = p2->next， p2 ->next=  0;
//此时原链表被分成了2个链表，头结点分别为head1, head2
//利用FirstCommonNode(ListNode * head1, ListNode * head2)函数得到相交节点FirtNode
//然后修复链表：common->next= head2
//最后返回FirstNode
ListNode * HasLoop(ListNode * head)
{
	if (!head)
	{
		return 0;
	}

	ListNode * slow = head;
	ListNode * quick = head;
	while(quick && quick->m_pNext)
	{
		slow = slow->m_pNext;
		quick = quick->m_pNext->m_pNext;
		if (slow == quick)
		{
			break;
		}
	}

	// 无环的话
	if (slow != quick )
	{
		return 0;
	}

	// p1表示相遇的点， p2表示p1->next
	//然后把p1->next 置为0
	//那么原链表形成了2个相交链表，一个以head为表头，一个以p2为表头
	ListNode * p1 = quick;
	ListNode * p2 = p1->m_pNext;
	p1->m_pNext = 0;
	ListNode * firtNode = FirstCommonNode(head,p2);

	p1->m_pNext = p2;
	return firtNode;
}


//给定单链表中某一个节点P,删除该节点（P节点不是最后节点）
//方法：首先存放好p中数据，然后把P->next中数据copy到p中，然后把p->next删除。
int DeleteNode(ListNode * p)
{
	if (!p)
	{
		return INT_MIN;
	}

	int tmp = p->m_nKey;
	ListNode * tmpNode = p->m_pNext;
	p->m_nKey = p->m_pNext->m_nKey;
	p->m_pNext = p->m_pNext->m_pNext;

	if (tmpNode != 0)
	{
		delete tmpNode;
		tmpNode = 0;
	}
}

//给定单链表中某一个非空节点P,在节点P前面插入一个节点
//方法：首先分配一个节点q,将q插在p点之后
//然后将p点数据copy到q节点中，然后再把要插入的数据放到p中
int InsertNode(ListNode * p, int data)
{
	if (!p)
	{
		return INT_MIN;
	}

	ListNode * tmpNode = new ListNode();
	tmpNode->m_nKey = p->m_nKey;
	tmpNode->m_pNext = p->m_pNext;
	p->m_pNext = tmpNode;

	p->m_nKey = data;

}

int main()
{

	int arr[] = {1, 2, 3};
	int brr[] = {4, 5, 6};
	int crr[] = {7, 8, 9};
	int alen = sizeof(arr)/sizeof(arr[0]);
	int blen = sizeof(brr)/sizeof(brr[0]);
	int clen = sizeof(crr)/sizeof(crr[0]);

	ListNode * head1 = 0;
	ListNode * head2 = 0;
	ListNode * head3 = 0;

	CreateList(head1, arr, alen);
	CreateList(head2, brr, blen);
	CreateList(head3, crr, clen);

	//合并链表1和链表3
	head1 = UnionList(head1, head3);
	//合并链表2和链表3
	head2 = UnionList(head2, head3);

	//打印链表1
	dump(head1);

	//打印链表2
	dump(head2);

	//寻找两个链表的第一个公共节点
	ListNode *findNode =  FirstCommonNode(head1, head2);
	printf("第一个公共节，地址为：Ox%x 值为：%d\n", findNode, findNode->m_nKey);

	findNode = HasLoop(head1);
	findNode == 0?printf("没有环\n"):printf("有环，换的入口节点值为：%d\n", findNode->m_nKey);
	return 0;
}


单链表判断公共节点
晓风残月xj
05-11 3354
单链表判断有无公共节点是个比较有趣的问题。这里所说的公共节点指的是完全相同的节点，不同与一般意义上的节点元素相同。相交单链表简单的都会是如下形式（有环除外）：                              粗略分析，容易想到就是暴力法，双重循环寻找公共节点。      关于单链表的判断有无公共节点，除了暴力法之外，还有很多方法可以尝试。下面简单列举几种。      可以尝试h
两个单向链表的第一个公共结点
怪咖小青年的博客
08-01 872
leetcode160：相交链表 题目： 编写一个程序，找到两个单链表相交的起始节点 实例： A: a1 → a2 ↘ c1 → c2 → c3 ↗ B: b1 → b2 → b3 思路： 因为链表是单向链表，所...
[转]判断两个链表是否有公共节点并返回第一个公共节点
weixin_33768481的博客
11-22 148
转自：http://blog.youkuaiyun.com/randyjiawenjie/article/details/6329572   判断两个链表是否有公共节点的方法最简单的就是遍历到每个链表的最后一个节点，看他们是否是同一个节点：如果是同一个节点的话，那么两个链表肯定有公共节点： 解释：因为链表是线性结构，不想树那样的非线性分叉结构 typedef struct LNode{ ...
两个链表中的第一个公共节点
rongdeguoqian的专栏
10-21 9007
题目：输入两个链表，找出它们的第一个公共节点。链表的定义如下： struct ListNode { int m_nKey; ListNode *m_pNext; }; 面试这道题的时候很多的面试者第一反应就是采用蛮力的方法：在第一个链表上顺序遍历每个节点，每遍历到一个节点的时候，在第二个链表上顺序遍历每个节点。如果第二个链表上的节点和第一个链表上的节点一样，就说明两个链
判断两条链表是否相交（公共部分）并找出相交处
weixin_33699914的博客
06-07 209
Problem： 　　两个单链表相交的一系列问题 　　【题目】 在本题中，单链表可能有环，也可能无环。给定两个 　　　　单链表的头节点 head1和head2，这两个链表可能相交，也可能 　　　　不相交。请实现一个函数， 如果两个链表相交，请返回相交的 　　　　第一个节点；如果不相交，返回null 即可。 　　要求： 　　　　如果链表1 的长度为N，链表2的长度为M，时间复杂度请达到 O(N ...
查找两个单链表的公共节点
许你一片梁城的博客
09-18 5170
查找两个单链表的公共节点 算法思路：首先要明白单链表有公共节点的情况是什么，因为单链表中每个节点的next指针是唯一的，所以当存在公共节点的时候，其后面的所有节点也都是相同的，所以这是的链表是一个“Y”，而不是我们惯性思维想到的“X”。根据这个结论可知，如果两个链表存在公共节点的话，它们的尾结点也肯定是相同的。 明白了有公共节点的链表构造之后就好办了，假设两个链表的长度分别是 len1 和 len2 第一种暴力方法：遍历第一个链表的节点，每个节点都再遍历第二个链表的所有节点，...
数据结构及算法：链表相关（如何判断单链表是否存在环、找出入环点、链表相交等问题）
天才小站
06-27 1418
目录 一、如何判断单链表是否存在环 方法一、穷举遍历 方法二、哈希表缓存 方法三、快慢指针（推荐） 方法四、Set集合大小变化 二、如何找出有环链表的入环点？ 方法一、用HashSet来解决 方法二、计算循环（快慢指针） 情况一：多走一个环 情况二、当fast比slow 多走n个环 代码实现 三、如果存在环，求出环上节点的个数； 四、如果存在环，求出链表的长度； ...
链表常见问题----链表相交，链表有环，链表反转以及链表倒数第n个节点
FramePyf的专栏
02-18 323
听小伙伴说经常在面试中会碰到如下几个问题： 1. 查找一个单向链表的倒数第n个节点 2. 链表反转 3. 链表是否有环，及环的入口 4. 两个无环的链表是否相交，及相交的第一个节点 那么这篇就来聊聊以上几个问题。 1.如何查找一个单向链表的倒数第n个节点 这个问题比较简单。 例如：要查找一个单向链表的倒数第4个节点。 那么只需要两个指针都指向头节点，一个指针从头节点开始先往后移动4个节点，然后两个指针同时移动。当先走4个节点的指...
算法：求两个单链表相交的第一个节点
Yufail的博客
03-06 1392
判断两个单链表是否相交以及相交的情况下求第一个相交节点，两个链表可以有环，也可以无环。因此我们可以从以下几个步骤分析： 判断一个单链表是否存在环路，如果无环，返回null，反之，返回入环节点。 如果两个单链表均无环，进入相应的子程序，如果无相交，返回null，反之，返回第一个相交节点。 如果一个有环，一个无环，进入相应的子程序，如果无相交，返回null，反之，返回第一个相交节点。 如果两个单链表...
两条相交的单向链表，如何求他们的第一个公共节点
Lieacui的专栏
07-27 3565
问题： 两个单向链表，可能存在公共节点。如何判断是否存在公共节点，并找出它们的第一个公共结点。 思想： 1. 如果两个链表相交，则从相交点开始，后面的节点都相同，即最后一个节点肯定相同； 2. 从头到尾遍历两个链表，并记录链表长度，当二者的尾节点不同，则二者肯定不相交； 3. 尾节点相同，如果A长为LA，B为LB，如果LA>LB,则A前LA-LB个先跳过，    然
11.6 | 找出两个单链表的公共结点(公共节点不是值相等)
m0_61831278的博客
11-06 133
【代码】11.6 | 找出两个单链表的公共结点(公共节点不是值相等)
判断两个单链表是否相交 输出入口点
b2utyyomi的博客
10-11 328
额 做这题用了我大半节实验课再加将近一个小时  样例过了 如果有错误 就麻烦路过的大牛指出来  额 很简单的思想到我这可能就。。。   我先做了两个链表 然后再做个交点出来 然后再判断再把L1放在L2后面， 形成一个环， 再找一下入口点就可以了 加注释的是我测试的时候写的 忽略就行 PS: 防弹这次歌真好听 jimin jimin jimin  下面上代码  /// first cre
单链公共结点问题
xueyingxue001的专栏
10-21 484
题目          给定两个单向链表，计算两个链表的第一个公共结点，若没有公共节点，返回空。 这道题的渊源          这道题的渊源如上图所示，求A和B的最近共同祖先(即上图蓝色箭头所示的那个点)，即：“A到根节点的路线”和“B到根节点的路线”相遇的离A和B最近的点。          而“A到根节点的路线”和“B到根节点的路线”是两个单向链表，因此这就是求两个单向链表的第一
如何判断链表是否相交、判断链表有环、判断相交链表第一个交点、判断环形链表入口节点
Xyg's LearningSpace
09-13 426
判断相交： 设置两个栈，分别将两个链表从第一个节点开始入栈，然后从栈顶开始比较出栈，如果第一个节点相等则相交，交点为最后一个相同节点。 判断有环： 方法一：使用HashSet遍历链表，并存入节点ID，每遍历到一个新节点就将其ID与集合中已有ID进行比较，相同则有环，不同则存入集合继续遍历直至节点指向NULL则证明无环。 方法二：设置两个指针，一个fast每次前进2个节点，slow每次前进一个...
链表之第一个公共子节点
weixin_53447671的博客
10-22 82
∴ length(a + b + c) = length(c + b + a) 且 无a、b、c无交集。使用四种方法，Hash、栈、链表拼接、差和四种方法解决寻找两链表第一个公共子节点问题。使用hash结构，如java中的HashSet，先将第一个链表的节点。输入两个链表，已知两个链表在相交处会形成单链表，求相交点的值；，弹出的数据作比较，若相等则用临时变量保存，然后继续弹栈，直到。使用栈来找出公共子节点，首先得先创建。，所以会从最后一个节点开始比较，此时，两个栈。，节约空间，但要注意的是，需要在。
两个单链表（无序），寻找第一个公共节点（如何判断单链表存在环）
zhanghx_seu的博客
08-18 899
1、两个单链表（无序），寻找第一个公共节点（如何判断单链表存在环）。 （1）循环嵌套 （2）线性时间复杂度算法。     如果两个链表有一个公共结点，那么 该公共结点之后的所有结点都是重合的。那么，它们的最后一个结点必然是重合的。因此，我们判断两个链表是不是有重合的部分，只要分别遍历两个链表到最后一 个结点。如果两个尾结点是一样的，说明它们用重合；否则两个链表没有公共的结点。 先要分别遍历
判断两个单链表是否相交同时找出第一个相交点（单链表是否有环及寻找入口节点）
在梅边的专栏
04-25 1948
这个问题，首先应判断两个单链表
如何判断两个有环单向链表是否有重合结点
chendequan的专栏
06-04 568
p1 = p2 = head1; do {      p1 = p1-> next;      p2 = p2-> next -> next;} while (p1 != p2);  p2 = p3 = head2;do {      p2 = p2 -> next;      p3 = p3 -> next -> next; } while (p2 != p3
单链表怎么判定有环和确定第一个入口节点
胖墩的IT博客
08-19 767
参考https://www.jianshu.com/p/09bb560ff025 给你一个单向链表，怎么判定他有环，如果有环请给出它的环的那个节点 1、首先分两步走，先看怎么判断有环 网上很多都有，我也是跟着他们的思路(谁叫他们脑回路复杂呢！) 看下面这个有环的链表(美术水平有限) 两个指针A，B，A一步走一个节点，B一步走两个节点。 此时说明此单链表有环，这是一个循环，停止条件就是B节点...
java输入两个无环的单向链表，找出它们的第一个公共结点，如果没 有公共节点则返回空。（注意因为传入数据是链表，所以错误测 试数据的提示是用其他方式显示的，保证传入数据是正确的） 数据范围：≤1000 要求：空间复杂度 O(1)，时间复杂度 O(n)
最新发布
03-30
<think>嗯，我现在要解决的问题是找到两个无环单链表的第一个公共节点，如果没有的话返回空。而且题目要求空间复杂度是O(1)，时间复杂度是O(n)。那我得仔细想想怎么做。 首先，单链表的公共节点意味着从某个节点开始，后面的所有节点都是相同的。也就是说，两个链表在某个点交汇之后，后面的节点都共享。比如，链表A在节点C处开始和链表B的节点C重合，那么C就是它们的第一个公共节点。 那我应该怎么找到这个节点呢？常见的思路可能有几种。比如，用哈希表存储其中一个链表的节点，然后遍历另一个链表，看是否有节点在哈希表中存在。第一个存在的节点就是公共节点。不过这样的话，空间复杂度是O(n)，不符合题目要求的O(1)。所以这种方法不行，得换其他方法。 那有没有空间O(1)的方法呢？这时候可能需要双指针的方法。我之前听说过一种方法，让两个指针分别从两个链表的头开始走，当走到末尾时，跳到另一个链表的头继续走。这样两个指针会在公共节点相遇。比如，链表A的长度是a，链表B的长度是b，公共部分的长度是c。那么，当两个指针走完各自的链表后，再走对方的链表，总路程是a + b - c，这样他们会在交汇点相遇。这个方法可能可行。 那具体怎么操作呢？假设链表A的长度是m，链表B的长度是n。如果两个链表有公共部分，那么从公共节点开始，后面的长度是一样的。所以，如果两个链表的长度不同，那么较长的链表的前面部分可能多出一些节点，这些节点不可能出现在公共部分。所以，我们可以先计算两个链表的长度差，让长的链表的指针先走这个差值的步数，然后两个指针再同时走，直到相遇。 比如，链表A比链表B长k步，那么让A的指针先走k步，然后两个指针同时走，这样当它们相遇的时候就是第一个公共节点。这种方法的时间复杂度是O(m+n)，空间复杂度是O(1)，符合要求。 那具体步骤应该是怎样的呢？首先，遍历两个链表，得到它们的长度。然后计算长度差，让较长的链表的指针先移动长度差的步数。然后同时移动两个指针，直到找到相同的节点或者走到末尾。 那这样的话，代码的结构大致是： 1. 遍历链表A，得到长度lenA； 2. 遍历链表B，得到长度lenB； 3. 计算差值diff = abs(lenA - lenB)； 4. 让较长的链表的指针先移动diff步； 5. 然后两个指针同时移动，直到它们相等； 6. 返回相遇的节点，或者null如果没有的话。 那这样是否正确呢？举个例子，假设链表A是1->2->3->4，链表B是5->3->4。公共节点是3。那么A的长度是4，B的长度是3。差值是1。让A的指针先移动1步到2，然后A的指针和B的指针同时移动：A的指针到3，B的指针到3，这时候相遇，返回正确节点。 另一个情况，如果两个链表没有公共节点，那么它们的指针最后都会走到null，这时候返回null即可。 这个方法应该可行。那现在需要考虑如何实现。代码的大致步骤： - 获取两个链表的长度。 - 移动长链表的头指针到和短链表相同长度的位置。 - 同时移动两个指针，直到找到相同节点。 那具体在Java中，怎么遍历链表？可以用循环，直到指针走到null。同时记录长度。 然后，调整长链表的起始点。比如，如果链表A较长，那么让指针curA先走diff步。然后curA和curB同时走，比较是否相等。 需要注意的是，当两个链表不相交的时候，两个指针会同时到达null，此时应该返回null。 那现在写代码的大体结构： public class Solution { public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) { // 计算两个链表的长度 int len1 = getLength(pHead1); int len2 = getLength(pHead2); // 调整指针到相同起始点 ListNode cur1 = pHead1; ListNode cur2 = pHead2; // 让长的链表的指针先移动差值步 if(len1 > len2){ int diff = len1 - len2; while(diff-- >0){ cur1 = cur1.next; } } else { int diff = len2 - len1; while(diff-- >0){ cur2 = cur2.next; } } // 同时移动指针，直到相遇或null while(cur1 != null && cur2 != null){ if(cur1 == cur2){ return cur1; } cur1 = cur1.next; cur2 = cur2.next; } return null; } private int getLength(ListNode head){ int len =0; while(head != null){ len++; head = head.next; } return len; } } 这样的代码应该可以解决问题。那时间复杂度是O(n + m)，空间复杂度是O(1)，因为只用了几个指针变量。 不过还有一种更巧妙的方法，不需要计算长度。也就是我之前提到的双指针交替遍历两个链表的方法。具体来说，指针A从链表A开始遍历，到末尾后跳到链表B继续遍历；指针B从链表B开始遍历，到末尾后跳到链表A继续遍历。这样，当两个指针相遇的时候，就是第一个公共节点。或者如果没公共节点，最终两个指针都走到null。 比如，链表A的长度是a，链表B的长度是b，公共部分长度是c。那么，指针A走的路径是a + (b -c)，指针B走的路径是 b + (a -c)。当相遇的时候，正好是公共节点。或者如果没有公共节点，那么他们走完a + b步后同时到达null。 这个方法的空间复杂度也是O(1)，时间复杂度是O(n + m)。这种方法是否可行？ 举个例子，链表A是1->2->3->4，链表B是5->3->4。指针A走的顺序是1,2,3,4,5,3,4。指针B走的顺序是5,3,4,1,2,3,4。当他们在第二个3的时候相遇。那这样是正确的。 那如何实现这种方法呢？代码可能更简洁。例如： public class Solution { public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) { ListNode a = pHead1; ListNode b = pHead2; while(a != b){ a = (a == null) ? pHead2 : a.next; b = (b == null) ? pHead1 : b.next; } return a; } } 这样的话，代码更简短，但可能效率一样。因为每个指针都走了两个链表的长度之和减去公共部分的长度。所以时间复杂度是O(n + m)，空间是O(1)。 那这两种方法哪种更好呢？两种方法都是满足条件的。但第二种方法更简洁，不需要计算长度。那为什么第一次想到的是第一种方法呢？可能因为第一种方法更直观，容易想到。 但是第二种方法是否存在什么问题？比如，当链表没有公共节点的时候，是否会陷入死循环？不会。因为当两个链表没有公共节点时，两个指针都会走到对方的尾部null，这时候a和b都为null，循环结束，返回null。 例如，链表A是1->2->3，链表B是4->5。a的遍历路径是1,2,3,null,4,5,null；b的遍历路径是4,5,null,1,2,3,null。当a和b都走到null的时候，循环条件a != b不成立，退出循环，返回a（此时是null），正确。 那这种方法是不是更优？是的。代码更简洁，不需要计算长度，也不需要考虑哪个链表更长。所以应该采用第二种方法。 所以最终的解决方案应该是第二种方法。那用户的问题是要求用Java实现，所以这样的代码是可行的。 那现在检查一下是否满足题目要求。题目中说明输入的是两个无环的单链表，所以不用担心循环的情况。而空间复杂度为O(1)，时间O(n)都满足。 综上，应该推荐使用双指针交替遍历的方法，即第二种方法。</think>### 问题分析 我们需要找到两个无环单链表的第一个公共节点，若不存在则返回空。要求空间复杂度为 $O(1)$，时间复杂度为 $O(n)$。以下是解决该问题的两种方法，其中第二种方法更为高效简洁。 --- ### 方法一：双指针对齐法 **核心思路** 1. **计算链表长度**：分别遍历两个链表，得到它们的长度差。 2. **对齐起点**：让较长链表的指针先移动长度差的步数，使得两个指针的起始位置对齐。 3. **同步遍历**：同时移动两个指针，找到第一个公共节点。 **代码实现** ```java public class Solution { public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) { int len1 = getLength(pHead1); int len2 = getLength(pHead2); ListNode cur1 = pHead1; ListNode cur2 = pHead2; // 对齐起点 if (len1 > len2) { int diff = len1 - len2; while (diff-- > 0) cur1 = cur1.next; } else { int diff = len2 - len1; while (diff-- > 0) cur2 = cur2.next; } // 同步遍历找公共节点 while (cur1 != null && cur2 != null) { if (cur1 == cur2) return cur1; cur1 = cur1.next; cur2 = cur2.next; } return null; } private int getLength(ListNode head) { int len = 0; while (head != null) { len++; head = head.next; } return len; } } ``` --- ### 方法二：双指针交替遍历法（更优） **核心思路** 1. **双指针交替遍历**：两个指针分别从链表头出发，遍历完当前链表后跳转到另一个链表的头部继续遍历。 2. **相遇条件**：若存在公共节点，两个指针会在遍历过程中相遇；若不存在，最终会同时到达 `null`。 **数学推导** 设链表 A 的非公共部分长度为 $a$，链表 B 的非公共部分长度为 $b$，公共部分长度为 $c$。 - 指针 A 的路径为 $a + b - c + c = a + b$ - 指针 B 的路径为 $b + a - c + c = a + b$ 两指针路径长度相同，最终会在公共节点相遇。 **代码实现** ```java public class Solution { public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) { ListNode a = pHead1, b = pHead2; while (a != b) { a = (a == null) ? pHead2 : a.next; // A遍历完跳转到B b = (b == null) ? pHead1 : b.next; // B遍历完跳转到A } return a; // 相遇点即为公共节点（若为null，说明无公共节点） } } ``` --- ### 方法对比 | 方法 | 时间复杂度 | 空间复杂度 | 实现复杂度 | |--------------------|------------|------------|------------| | 双指针对齐法 | $O(n)$ | $O(1)$ | 中等 | | 双指针交替遍历法 | $O(n)$ | $O(1)$ | 简单 | 推荐使用**方法二**，代码简洁且无需显式计算长度，直接通过交替遍历解决。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值