文章目录
- 题目描述
- 题目难度——简单
- 方法一：数数，然后遍历
- 代码/C++
- 方法二：双指针
- 代码/C++
- 代码/Python
- 总结
题目描述
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
- 示例 1：
-
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘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
输出：Intersected at ‘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 。
题目难度——简单
方法一：数数，然后遍历
注意，这个题要求判断的是结点相交，也就是结点要相同，而不是结点上的值相同，不注意的话很容易把判断条件写成值是否相同。
如果两个链表长度相同，那就可以从开头开始遍历，每次看当前位置往后的节点是否都相同，是的话就返回当前结点，否则就继续往后看，这是最简单也是最容易想到的方法，但是效率很差，要先遍历两个链表数有多少个结点，然后还要再遍历一次，每次还要往后遍历，效率很差，不推荐。
代码/C++
/**
* 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 *pa, *pb, *tmpa, *tmpb;
pa = headA, pb = headB;
int lena = 0, lenb = 0, k;
while(pa || pb){
if(pa){
lena++;
pa = pa->next;
}
if(pb){
lenb++;
pb = pb->next;
}
}
pa = lena > lenb ? headA : headB;
pb = lena > lenb ? headB : headA;
k = lena > lenb ? lena - lenb : lenb - lena;
while(k){
pa = pa->next;
k--;
}
bool tag = false;
while(pa && pb){
tag = true;
tmpa = pa, tmpb = pb;
while(tmpa && tmpb){
if(tmpa != tmpb){
tag = false;
break;
}
tmpa = tmpa->next;
tmpb = tmpb->next;
}
if(tag){
return pa;
}
pa = pa->next;
pb = pb->next;
}
return NULL;
}
};
方法二：双指针
这个办法也是在上一个的基础上想了半天想不出来更好的之后，去评论区学习的，大佬链接，基于这样一个实时，如果拿两个指针同时遍历一次两个链表并计数，那么最后两个指针走过的节点数肯定相同，而假如两个链表有交叉点的话，两个指针在遍历的过程中肯定会碰到，于是就可以写出很简单的代码了。
代码/C++
/**
* 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 *pa = headA, *pb = headB;
while(pa != pb){
pa = pa ? pa->next : headB;
pb = pb ? pb->next : headA;
}
return pa;
}
};
代码/Python
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
pa, pb = headA, headB
while pa != pb:
pa = pa.next if pa else headB
pb = pb.next if pb else headA
return pa
总结
第一种方法，如果两个链表长度一样（n），且不相交的话，最坏就要比较(n + n - 1 + n- - 2 +…+1)次，所以时间是O(N2)，只用到了几个变量，因此空间是O(1)。第二种方法只需要遍历一次两个链表，所以时间是O(N)，空间同样是O(1)。
