leetcode刷题/每日一题 剑指 Offer 52. 两个链表的第一个公共节点

剑指 Offer 52. 两个链表的第一个公共节点

题意:

输入两个链表，找出它们的第一个公共节点。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2
输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
解释：这两个链表不相交，因此返回 null。

解题思想:

这道题我看了一会,然后想到了一个简单的方法,

• 先把链表的值用数组存储起来
• 然后数组A,B从后面开始寻找数相同的下标值,直到他们两个下标的值不同(如果有交集那么后面的值必定相同)
• 然后让指针移动到他们相同的值开始的节点.(步数就是上面寻找到的不同值的下标)
• 进入一个循环,在这相同的值开始判断如果他们两个的地址相同,说明这个点就是交点.

代码:

/**
 * 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) {
      
    //指针为空时无焦点
    if (headA == nullptr || headB == nullptr)
		return nullptr;
    
    //创建两个数组来接受链表的数据
	vector<int> va;
	vector<int> vb;          
	ListNode *p = headA;
	while (p != nullptr)
	{
		va.push_back(p->val);
		p = p->next;    
	}           
	p = headB;
	while (p != nullptr)
	{
		vb.push_back(p->val);
		p = p->next;
	}
        
    //寻找相同值     
	int indexA = va.size() - 1;
	int indexB = vb.size() - 1;          
	while (indexA >= 0 && indexB >= 0 && va[indexA] == vb[indexB])
	{
		indexA--;
		indexB--;
	}
        
    //让指针指向相同值的开始位置,需要+1是因为上面有等于0的情况,从-1开始
	p = headA;
	for (int i = 0; i < indexA + 1; i++)
		p = p->next;
	ListNode *sup_a = p;
             
	p = headB;
	for (int i = 0; i < indexB + 1; i++)
		p = p->next;
	ListNode *sup_b = p;
        
        
    //从相同值的位置开始,如果他们两个都不为空切两个的地址相同,说明这个点就是焦点,有一个为空说明没有焦点
	while (sup_a != nullptr && sup_b != nullptr && sup_a != sup_b)
	{
		sup_a = sup_a->next;
		sup_b = sup_b->next;
	}
	if (sup_a == nullptr || sup_b == nullptr)
		return nullptr;
	return sup_a;    
    }
};

运行结果:

总结:

这道题我想到的简单方法就是利用数组可以回退,焦点后面的值必定是相同的,沿着这个思路我只需要找到相同的值开始的位置,然后往后开始判断是否是焦点(值相同不一定是焦点). 我做的时候卡在了移动指针到节点开始那里,因为index有-1的情况,所有后面移动的时候记得要+1.利用了两个数组空间,所有空间复杂度是O(m + n).时间复杂度也是一样,