Intersection of Two Linked Lists

本文提供了一种高效的算法来查找两个单链表相交的起始节点,通过比较链表长度并调整指针位置,最终实现O(n)时间复杂度和O(1)内存使用。

Write a program to find the node at which the intersection of two singly linked lists begins.


For example, the following two linked lists:

A:          a1 → a2
                   ↘
                     c1 → c2 → c3
                   ↗            
B:     b1 → b2 → b3

begin to intersect at node c1.


Notes:

  • If the two linked lists have no intersection at all, return null.
  • The linked lists must retain their original structure after the function returns.
  • You may assume there are no cycles anywhere in the entire linked structure.
  • Your code should preferably run in O(n) time and use only O(1) memory.
class Solution {
public:
	ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) 
	{
		if (0 == headA || 0 == headB) return 0;
		int lenA = 0, lenB = 0;
		ListNode A(0), B(0), *pA = &A, *pB = &B;
		pA->next = headA;
		pB->next = headB;

		while(pA->next != 0)
		{
			++lenA;
			pA = pA->next;
		}
		while(pB->next != 0)
		{
			++lenB;
			pB = pB->next;
		}
		if (pA != pB) 
			return 0;
		int diff = abs(lenA - lenB);
		pA = &A; // make a fatal endless loop mistak here.
		pB = &B;
		pA->next = headA;
		pB->next = headB;
		if (lenA > lenB)
		{
			while (diff-- > 0)
				pA = pA->next;
		}
		else if (lenA < lenB)
		{
			while (diff-- > 0)
				pB = pB->next;
		}
		while (1)
		{
			if (pA->next == pB->next)
				return pA->next;
			pA = pA->next;
			pB = pB->next;
		}        	
	}
};


以下对使用双指针 `p` 和 `q` 遍历链表来求解两个链表相交节点的逻辑和原理进行分析。 ### 代码逻辑 ```cpp /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { ListNode* p = headA; ListNode* q = headB; while (p != q) { p = p ? p->next : headB; q = q ? q->next : headA; } return p; } }; ``` ### 原理分析 1. **初始化指针**:定义两个指针 `p` 和 `q`,分别指向链表 `A` 和链表 `B` 的头节点。 2. **遍历链表**:使用 `while` 循环,只要 `p` 不等于 `q`,就继续循环。在每次循环中,如果 `p` 不为空,就将 `p` 指向下一个节点;如果 `p` 为空,就将 `p` 指向链表 `B` 的头节点。对于 `q` 指针同理,如果 `q` 不为空,就将 `q` 指向下一个节点;如果 `q` 为空,就将 `q` 指向链表 `A` 的头节点。 3. **找到相交节点**:当 `p` 等于 `q` 时,循环结束,此时 `p`(或 `q`)所指向的节点就是两个链表的相交节点。如果两个链表不相交,那么最终 `p` 和 `q` 都会指向 `nullptr`。 ### 具体解释 - **相交情况**:假设链表 `A` 的长度为 `m`,链表 `B` 的长度为 `n`,两个链表相交部分的长度为 `k`。那么链表 `A` 不相交部分的长度为 `m - k`,链表 `B` 不相交部分的长度为 `n - k`。当 `p` 遍历完链表 `A` 后,会指向链表 `B` 的头节点;当 `q` 遍历完链表 `B` 后,会指向链表 `A` 的头节点。此时,`p` 和 `q` 走过的路程分别为 `m + (n - k)` 和 `n + (m - k)`,由于 `m + (n - k) = n + (m - k)`,所以 `p` 和 `q` 会在相交节点处相遇。 - **不相交情况**:如果两个链表不相交,那么 `p` 和 `q` 会分别遍历完链表 `A` 和链表 `B`,然后同时指向 `nullptr`,此时 `p` 等于 `q`,循环结束,返回 `nullptr`。 ### 复杂度分析 - **时间复杂度**:$O(m + n)$,其中 `m` 和 `n` 分别是两个链表的长度。因为每个指针最多遍历两个链表各一次。 - **空间复杂度**:$O(1)$,只使用了常数级的额外空间。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值