链表6：链表相交（面试题02.07）

本题如下：（链接：https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/）

题目：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

 

 

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

 

 

 

 

 

 

 

思路：这道题其实并不复杂，简单来说，就是求两个链表交点节点的指针。 这里需要注意，交点不是数值相等，而是指针相等。

为了方便举例，假设节点元素数值相等，则节点指针相等。

看如下两个链表，目前curA指向链表A的头结点，curB指向链表B的头结点：

 

 

 

 我们求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，如图：

 

 

此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。

否则循环退出返回空指针。

 

 

那么就可以得到相应的C++代码：

 1 class Solution {
 2 public:
 3     ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
 4         ListNode* curA = headA;
 5         ListNode* curB = headB;
 6         int lenA = 0, lenB = 0;
 7         while (curA != NULL) { // 求链表A的长度
 8             lenA++;
 9             curA = curA->next;
10         }
11         while (curB != NULL) { // 求链表B的长度
12             lenB++;
13             curB = curB->next;
14         }
15         curA = headA;
16         curB = headB;
17         // 让curA为最长链表的头，lenA为其长度
18         if (lenB > lenA) {
19             swap (lenA, lenB);
20             swap (curA, curB);
21         }
22         // 求长度差
23         int gap = lenA - lenB;
24         // 让curA和curB在同一起点上（末尾位置对齐）
25         while (gap--) {
26             curA = curA->next;
27         }
28         // 遍历curA 和 curB，遇到相同则直接返回
29         while (curA != NULL) {
30             if (curA == curB) {
31                 return curA;
32             }
33             curA = curA->next;
34             curB = curB->next;
35         }
36         return NULL;
37     }
38 };

其中，时间复杂度为：O(n + m)，空间复杂度为：O(1)。

 

 

同样地，下面给出Java版本的代码：

 1 public class Solution {
 2     public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
 3         ListNode curA = headA;
 4         ListNode curB = headB;
 5         int lenA = 0, lenB = 0;
 6         while (curA != null) { // 求链表A的长度
 7             lenA++;
 8             curA = curA.next;
 9         }
10         while (curB != null) { // 求链表B的长度
11             lenB++;
12             curB = curB.next;
13         }
14         curA = headA;
15         curB = headB;
16         // 让curA为最长链表的头，lenA为其长度
17         if (lenB > lenA) {
18             //1. swap (lenA, lenB);
19             int tmpLen = lenA;
20             lenA = lenB;
21             lenB = tmpLen;
22             //2. swap (curA, curB);
23             ListNode tmpNode = curA;
24             curA = curB;
25             curB = tmpNode;
26         }
27         // 求长度差
28         int gap = lenA - lenB;
29         // 让curA和curB在同一起点上（末尾位置对齐）
30         while (gap-- > 0) {
31             curA = curA.next;
32         }
33         // 遍历curA 和 curB，遇到相同则直接返回
34         while (curA != null) {
35             if (curA == curB) {
36                 return curA;
37             }
38             curA = curA.next;
39             curB = curB.next;
40         }
41         return null;
42     }
43 
44 }

 

标签：lenB,lenA,ListNode,02.07,面试题,链表,curB,curA
来源： https://www.cnblogs.com/cnwsh/p/16576983.html