目录
- 160_相交链表
- 描述
- 解法一：哈希表
- 思路
- Java 实现
- Python 实现
- 解法二：双指针（推荐）
- 思路
- Java 实现
- Python 实现
160_相交链表
描述
编写一个程序，找到两个单链表相交的起始节点。
例如，下面的两个链表：
A: a1 → a2↘c1 → c2 → c3↗
B: b1 → b2 → b3在节点 c1 开始相交。
注意：
- 如果两个链表没有交点，返回
null. - 在返回结果后，两个链表仍须保持原有的结构。
- 可假定整个链表结构中没有循环。
- 程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。
致谢:
特别感谢 @stellari 添加此问题并创建所有测试用例。
解法一：哈希表
思路
首先遍历链表 A 的所有节点，并将每个节点的引用存入哈希表中。接着，遍历链表 B 的每个节点，如果某个节点的引用在哈希表中存在，返回该节点的引用；如果遍历完链表 B 的所有节点没有发现这样一个节点，则返回 null。
Java 实现
/*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode(int x) {* val = x;* next = null;* }* }*/
public class Solution {public ListNode getIntersectionNode(ListNode headA, ListNode headB) {if (headA == null || headB == null) {return null;}Set<ListNode> nodes = new HashSet<>();ListNode temp = headA;while (temp != null) {nodes.add(temp);temp = temp.next;}temp = headB;while (temp != null) {if (nodes.contains(temp)) {return temp;}temp = temp.next;}return null;}
}复杂度分析：
- 时间复杂度：\(O(m+n)\)，其中，\(m\) 表示链表 A 的节点数，\(n\) 表示链表 B 的节点数，最坏的情况下，需要遍历两个链表的所有节点
- 空间复杂度：\(O(m)\) 或者 \(O(n)\)
Python 实现
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = Noneclass Solution(object):def getIntersectionNode(self, headA, headB):""":type head1, head1: ListNode:rtype: ListNode"""if not headA or not headB:return NonenodesA = set()curr = headAwhile curr:nodesA.add(curr)curr = curr.nextcurr = headBwhile curr:if curr in nodesA:return currcurr = curr.nextreturn None复杂度分析同上。
解法二：双指针（推荐）
思路
双指针解法顾名思义需要两个指针，假设指针 pA 和 pB 分别指向链表 A 和链表 B 的头结点，之后两个指针分别以步幅为 1 的速度向链表的尾部遍历，当指针 pA 遍历到链表 A 的尾节点时，将指针 pA 指向链表 B 的头部。同样地，当指针 pB 遍历到链表 B 的尾节点时，将指针 pB 指向链表 A 的头部。当两个指针相遇时，指针 pA 或者 pB 所指向的节点就是两个链表的相交节点。
为了说明双指针的求解思路，假设链表 A 和链表 B 的结构如下图所示，
其中，链表 A 包含 6 个节点，节点的值分别为 1、3、5、7、9 和 11；链表 B 包含 4 个节点，节点的值分别为 2、4、9 和 11，因此，两个链表的相交节点为 9。设链表 A 中不相交的部分（即蓝色部分的节点）长度为 \(L1\)，链表 B 中不相交的部分（即黄色部分的节点）长度为 \(L2\)，两个链表相交的部分（即红色部分的节点）长度为 \(L3\)。
如下图所示，当指针 pB 遍历到链表 B 的尾节点 11 时，指针 pA 遍历到链表 A 中节点 7 的位置，下一次遍历指针 pB 将处于链表 A 的节点 1 的位置。
同理，当指针 pA 遍历到链表 A 的尾节点 11 时，此时指针 pB 处于链表 A 中节点 3 的位置，下一次遍历指针 pA 将处于链表 B 的节点 2 位置。
再经过两次遍历后，指针 pA 将位于链表 B 中节点 4 的位置，而指针 pB 也将到达链表 A 的节点 4 的位置，下一次遍历两个指针将在节点 9（即相交节点）相遇。此时，两个指针走过的长度都为 \(L1 + L2 + L3\)。究其原因，可以将两个指针走过的“路程”看成 3 个部分，即蓝色部分、红色部分以及橙色部分，只是两个指针走过 3 个部分的顺序是不同的，指针 pA 先走蓝色部分而指针 pB 先走橙色部分，但是经过前 3 个部分后，两个指针走过的长度一定是相同的，因此在下一次遍历的时候两个指针一定会相遇。
Java 实现
/*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode(int x) {* val = x;* next = null;* }* }*/
public class Solution {public ListNode getIntersectionNode(ListNode headA, ListNode headB) {if (headA == null || headB == null) {return null;}ListNode pA = headA;ListNode pB = headB;while (pA != pB) {pA = pA == null ? headB : pA.next;pB = pB == null ? headA : pB.next;}return pA;}
}复杂度分析：
- 时间复杂度：\(O(L1 + L2 + L3) = O(n)\)，如果两个链表存在相交节点，则经过 \(L1 + L2 + L3\) 的“长度”后，两个指针一定会相遇
- 空间复杂度：\(O(1)\)，只需要保存两个引用
Python 实现
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = Noneclass Solution(object):def getIntersectionNode(self, headA, headB):""":type head1, head1: ListNode:rtype: ListNode"""if not headA or not headB:return Nonep_a, p_b = headA, headBwhile p_a != p_b:if p_a:p_a = p_a.nextelse:p_a = headBif p_b:p_b = p_b.nextelse:p_b = headAreturn p_a复杂度分析同上。
