剑指 Offer（第2版）面试题 52：两个链表的第一个公共结点

剑指 Offer（第2版）面试题 52：两个链表的第一个公共结点

题目来源：AcWing 66. 两个链表的第一个公共结点

解法1：计算链表长度

先计算出两个链表的长度，可以让比较长的先走两个链表长度之差的步数，两个再一起走。

即使两个链表没有公共部分，它们都是同时到达自己的链表尾，都为 nullptr，返回 p1，也就是 nullptr，符合题意。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution
{
public:
	ListNode *findFirstCommonNode(ListNode *headA, ListNode *headB)
	{
		if (headA == nullptr || headB == nullptr)
			return nullptr;
		int lenA = listLength(headA), lenB = listLength(headB), diff = abs(lenA - lenB);
		ListNode *p = lenA > lenB ? headB : headA, *q = lenA > lenB ? headA : headB;
		while (diff--)
			q = q->next;
		while (p != q)
		{
			p = p->next;
			q = q->next;
		}
		return q;
	}
	// 辅函数 - 计算链表长度
	int listLength(ListNode *head)
	{
		if (head == nullptr)
			return 0;
		int length = 0;
		ListNode *p = head;
		while (p)
		{
			p = p->next;
			length++;
		}
		return length;
	}
};

复杂度分析：

时间复杂度：O(lenA+lenB)，其中 lenA 是链表 A 的长度， lenB 是链表 B 的长度。

空间复杂度：O(1)。

解法2：双指针

假设链表 A 的单独部分的长度为 a， 链表 B 的单独部分的长度为 b，两个链表的公共部分长度为 c。

以下图为例：

a = 2，b = 3，c = 3。

我们发现有：a + c + b = b + c + a。

于是我们让两个指针一起走，pa 走到头就转向 headB，然后继续走；pb 走到头转向headA，然后继续走。最后 pa 和 pb 在公共部分的第一个节点相遇。

即使两个链表没有公共部分，pa 和 pb 都是同时到达链表 A 和链表 B 的链表尾（a + b = b + a），都为 nullptr，返回 pa，也就是 nullptr，符合题意。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution
{
public:
	ListNode *findFirstCommonNode(ListNode *headA, ListNode *headB)
	{
		if (headA == nullptr || headB == nullptr)
			return nullptr;
		ListNode *p1 = headA, *p2 = headB;
		while (p1 != p2)
		{
			if (p1)
				p1 = p1->next;
			else
				p1 = headB;
			if (p2)
				p2 = p2->next;
			else
				p2 = headA;
		}
		return p1;
	}
};

复杂度分析：

时间复杂度：O(lenA+lenB)，其中 lenA 是链表 A 的长度， lenB 是链表 B 的长度。

空间复杂度：O(1)。

解法3：栈

分别把两个链表的节点放入两个栈中，这样两个链表的尾节点就位于两个栈的栈顶，接下来比较两个栈顶的节点是否相同。如果相同，则弹出，接着比较下一个栈顶，直到找到最后一个相同的节点。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *findFirstCommonNode(ListNode *headA, ListNode *headB) {
        if(headA == nullptr || headB == nullptr)
            return nullptr;
            stack<ListNode *> stkA, stkB;
            ListNode *pA = headA, *pB = headB;
            while(pA)
            {
                stkA.push(pA);
                pA = pA->next;
            }
            while(pB)
            {
                stkB.push(pB);
                pB = pB->next;
            }
            ListNode *sameNode = nullptr;
            while(!stkA.empty() && !stkB.empty())
            {
                if(stkA.top() == stkB.top())
                {
                    sameNode = stkA.top();
                    stkA.pop();
                    stkB.pop();
                }
                else
                    break;
            }
            return sameNode;
    }
};

复杂度分析：

时间复杂度：O(lenA+lenB)，其中 lenA 是链表 A 的长度， lenB 是链表 B 的长度。我们对链表 A 和链表 B 各遍历一次，将其节点分别插入 stkA 和 stkB。

空间复杂度：O(lenA+lenB)，其中 lenA 是链表 A 的长度， lenB 是链表 B 的长度。栈 stkA 和 stkB 的空间开销。