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

方法一. 常规做法

先确定两个链表的长度，然后让指向长链表的指针先走，走到某个节点，使得从该节点到长链表尾的距离等于锻炼表的长度，然后两指针再同步走，一直走到底，如果走到底则说明不想交，否则在之前应该已经相遇。

/**
 * 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) {
        ListNode p = headA, q = headB;
        // 找链表长度
        int m = 0, n = 0;
        while (p != null) {
            m++;
            p = p.next;
        }
        while (q != null) {
            n++;
            q = q.next;
        }
        // 让长链表指针先走到预定位置，使之后的长度相同
        p = headA;
        q = headB;
        while (m > n) {
            p = p.next;
            m--;
        }
        while (n > m) {
            q = q.next;
            n--;
        }
        // 比较判断，要么一起走到null，要么找到相同节点，注意要用!= 不能用equals
        while (p != null  && p != q) {
            p = p.next;
            q = q.next;
        }
        if (p == null)
            return null;
        return p;
    }
}

时间复杂度 O ( m + n ) O(m+n) O(m+n) 最多两个指针各走两遍整个链表

空间复杂度 O ( 1 ) O(1) O(1)

方法二浪漫相遇

假设一个链表 A A A 长为 m m m，另一个链表 B B B 长为 n n n，如果相交，假设相交部分长为 k ( k < = m , k < = n ) k\ (k <= m, k <= n) k (k<=m,k<=n) 。让两个链表指针同步跑，如果有某一个指针先走到尾部（即 n u l l null null)则让它再跑到对面的链表头部，再跑，这样不论相交或是不想交，总会找到某一个点使得两个指针 p p p 和 q q q 相遇（要么是在 $ null$处，要么是在相交点）。为方便叙述和理解，假设第一次赋值 p = h e a d A , q = h e a d B p = headA, q = headB p=headA,q=headB为第1步：

相交：不妨第一个链表更长一些（即 m > n m > n m>n )，则指针 q q q 先走到链表尾部，然后转向第一个链表头部继续前进，同样到某个时候指针 p p p 也走到链表尾部再转向第二个链表头部继续前进。当走到第 m + n − k m+n-k m+n−k 步时，必定相遇。

原因: （如果链表长度不相同）
当走到第 n + 1 n+1 n+1步时， q q q本来指向 n u l l null null, 我们让它转向 q = h e a d A q = headA q=headA，而 p p p 还在链表 A A A上的第 n + 1 n+1 n+1 个位置。
然后当走到第 m + 1 m+1 m+1步时， p p p要转向， p = h e a d B p = headB p=headB 即 p p p在链表 B B B的1号位置， q q q 在链表 A A A上的第 m − n + 1 m-n+1 m−n+1个位置 ( m + 1 − ( n + 1 ) + 1 = m − n + 1 m+1 - (n+1) + 1 = m-n+1 m+1−(n+1)+1=m−n+1)， p p p再往前走 n − k − 1 n-k-1 n−k−1步， p p p走到了链表 B B B的第 n − k n-k n−k个位置，即相交点。
同理， q q q 再往前走 n − k − 1 n-k-1 n−k−1步也走到链表A的第 m − k m-k m−k个位置，即相交点。即 p p p和 q q q都走了 m + n − k m+n-k m+n−k步，到达相交点（如果还是很难理解，照着我的描述画个图即可）

（如果链表长相同）

那就简单了，只要走一遍，就会同时走到相交点
不想交：比较简单，两个指针分别走到链表尾，如果链表长相等则同时走到链表尾，如果不相等则先走一遍自己的链表再走一遍对面的链表，总共走 m + n m+n m+n步同时再次来到链表尾

因此，它们不论链表长是否相同，不论是否会相交，终究会走到同时相交点或者链表尾，可以利用 p ! = q p\space !=\space q p != q作为循环条件， p = = n u l l p == null p==null来判断是否相交

/**
 * 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) {
        ListNode p = headA, q = headB;
        while (p != q) {
            p = p != null ? p.next : headB;
            q = q != null ? q.next : headA;
        }
        return p;
    }
}

时间复杂度 O ( m + n ) O(m+n) O(m+n)：最多走 m + n m+n m+n步
但是方法二的系数比方法一要小，而且更优美

空间复杂度 O ( 1 ) O(1) O(1) ：只使用了两个指针，占用常量空间

运行结果：打败100%

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

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

方法一. 常规做法

方法二 浪漫相遇

方法二浪漫相遇