单链表系列问题

. 问题描述

这道题目主要讨论单链表相交的一系列问题。在本题中，单链表可能有环，也可能无环。给定两个单链表的头节点 head1 和 heda2 ，这两个链表可能相交，也可能不相交。请实现一个函数，如果两个链表相交，请返回相交的第一个节点；如果不相交返回 null 即可。

要求：如果链表 1 的长度为N，链表 2 的长度为 M，时间复杂度请达到 O(N+M),空间复杂带请达到 O(1)。

. 解题思路

这道题需要分析的情况非常多，同时因为有额外空间复杂度为 O(1) 的限制，非常具有挑战。
这道题可以使用数学中的分类讨论思想，分成三个子问题：

问题一：如何判断一个链表是否相交，相交则返回第一个相交节点，不相交则返回 null。

问题二：如何判断两个无环链表是否相交，相交则返回第一个相交节点，不相交则返回null。

问题三：如何判断两个有环链表是否相交，相交则返回第一个相交节点，不相交则返回null。
这道题目主要就两个任务：一是如何判断有环，二是如何判断相交。在判断相交分两种情况，两个无环链表是否相交，两个有环链表是否相交。

注意：如果一个链表有环，另外一个链表无环，它们是不可能相交的，直接返回null。

. 代码实现

下面逐个分析每个问题。
问题一：如何判断一个链表是否相交，相交则返回第一个相交节点，不相交则返回 null。
如果一个链表没有环，那么遍历链表一定可以遇到链表的终点；如果一个链表有环，那么遍历链表就永远在环里转下去了。下面给出找到第一个入环节点的思路：

1. 使用一个快指针 fast，和一个慢指针 slow，快指针的移动速度是慢指针的2倍；
2. 如果链表没有环，fast 先到链表尾，且next为null；
3. 如果链表有环，最后快指针和慢指针会在某个位置相遇，即 slow==fast；
4. 此时让其中一个指针指向head，例如 slow = head，然后slow，fast速度同步继续往前，当 slow == fast，此时的节点便是第一个入环的节点。
   代码实现如下：

 1//问题一：如何判断一个链表是否有环，如果有，则返回进入环的第一个节点，否则返回null
 2    public  Node getLoopNode(Node head) {
 3        if (head == null || head.next == null || head.next.next == null) {
 4            return null;
 5        }
 6        Node slow = head.next;
 7        Node fast = head.next.next;
 8        while (slow != fast) {
 9             //当快指针指向null时，说明没有环，则返回null
10            if (slow.next == null || fast.next.next == null) {
11                return null;
12            }
13            fast = fast.next.next;
14            slow = slow.next;
15        }
16        fast = head;
17        while (slow != head) {
18            slow = slow.next;
19            fast = fast.next;
20        }
21        return slow;
22    }

问题二：如何判断两个无环链表相交，相交则返回第一个相交节点，否则返回null
如果两个无环链表相交，那么从相交节点开始，直到链表表尾，这段节点是两个链表共享的。思路如下：

1. 遍历两个无环链表，并统计链表的长度，len1、len2；
2. 判断两个链表的 end 节点是否相等，如果 end1 != end2,两个链表无相交，直接返回null；end1 == end2，两个链表相交，进入3，寻找相交的第一个节点；
3. 如果len1-len>0，则链表1 先走 len1-len2 的长度，如果len2-len1>0，则链表2先走len2-len1的长度，然后两个链表一起向前走，当链表第一次走到一起的那个节点时，这个节点就是相交的第一个节点。
   代码实现如下：

 1//问题二：如何判断两个无环链表相交，相交则返回第一个相交节点，否则返回null
 2     public  Node noLoop(Node head1,Node head2) {
 3        if (head1 == null || head2 == null) {
 4            return null;
 5        }
 6        Node cur1 = head1;
 7        Node cur2 = head2;
 8        int n = 0;
 9        while (cur1.next != null) {
10            n++;
11            cur1 = cur1.next;
12        }
13        while (cur2.next != null) {
14            n--;
15            cur2 = cur2.next;
16        }
17        cur1 = n > 0 ? head1 : head2;//cur1 始终指向较长链表的head
18        cur2 = cur1 == head1 ? head2 : head1;
19        n = Math.abs(n);
20        while (n != 0) {
21            n--;
22            cur1 = cur1.next;//较长的链表先行
23        }
24        while (cur1 != cur2) {
25            cur1 = cur1.next;
26            cur2 = cur2.next;
27        }
28        return cur1;
29     }

问题三：如何判断两个有环链表是否相交，相交则返回第一个相交节点，否则返回null
在解决问题三的时候，已经可以通过前面的方法可以获得入环的第一个节点了，假设链表 1 的第一入环节点为 loop1，链表二的第一个入环节点为 loop2。具体思路如下：

1. 如果链表的loop1、loop2 相等，则链表1和链表2相交的第一个节点在 loop1 之前，只需使用问题二的方式找出即可，唯一的区别，问题二链表的终点是null ，而这里终点是loop1 或 loop2；
2. 如果 loop1 != loop2 ,让 节点从loop1 开始，因为链表有环，所以肯定会回到 loop1，如果在这个过程中，遇到了loop2 ，则说明两个链表相交，返回loop1 或者loop2 ，如果没有遇到 loop2 ，则说明两个链表不相交，返回null 即可。
   代码实现如下：

 1//问题三：如何判断两个有环链表是否相交，相交则返回第一个相交节点，否则返回null
 2     public  Node bothLoop (Node head1,Node loop1,Node head2,Node loop2) {
 3            Node cur1 = null;
 4            Node cur2 = null;
 5            //说明第一次相交的节点在 loop1 之前
 6            if (loop1 ==  loop2 ) {
 7                cur1 = head1;
 8                cur2 = head2;
 9                int n = 0;
10                while (cur1.next != loop1) {
11                    n++;
12                    cur1 = cur1.next;
13                }
14                while (cur2.next != loop2) {
15                    n--;
16                    cur2 = cur2.next;
17                }
18                cur1 = n>0 ? head1 : head2;
19                cur2 = cur1==head1 ? head2 : head1;
20                n = Math.abs(n);
21                while (n != 0) {
22                    n--;
23                    cur1 = cur1.next;
24                }
25                while (cur1 != cur2) {
26                    cur1 = cur1.next;
27                    cur2 = cur2.next;
28                }
29                return cur1;
30
31            } else {
32                //第一次相交的节点为 loop1 或 loop2
33                cur1 = loop1.next;
34                while (cur1 != loop1) {
35                    if (cur1 == loop2) {
36                        return loop1;
37                    }
38                    cur1 = cur1.next;
39                }
40                return null;
41            }
42     }

回到最开始的那个问题，全部的实现过程看如下代码，这也是整个问题的主方法。

 1class Node {
 2        private int data;
 3        private Node next;
 4        public Node(int data) {
 5            this.data = data;
 6        }
 7public  Node getIntersectNode(Node head1,Node head2) {
 8            if (head1 == null || head2 == null) {
 9                return null;
10            }
11            //获取两个链表的第一个入环节点（如果有）
12            Node loop1 = getLoopNode(head1);
13            Node loop2 = getLoopNode(head2);
14            //如果第一个入环节点为空，说明是问题二的情况
15            if (loop1 == null & loop2 == null) {
16                return noLoop(head1,head2);
17            }
18            //如果第一个入环节点不为空，说明是问题三的情况
19            if (loop1 != null & loop2 != null) {
20                return bothLoop(head1,loop1,head2,loop2);
21            }
22            return null;
23     }