刷题日记-链表中的环

判断链表中是否有环

描述
判断给定的链表中是否有环。如果有环则返回true，否则返回false。
数据范围：链表长度 0≤n≤10000，链表中任意节点的值满足∣val∣<=100000
要求：空间复杂度 O(1)，时间复杂度 O(n)

输入分为两部分，第一部分为链表，第二部分代表是否有环，然后将组成的head头结点传入到函数里面。-1代表无环，其它的数字代表有环，这些参数解释仅仅是为了方便读者自测调试。实际在编程时读入的是链表的头节点。
例如输入{3,2,0,-4},1时，对应的链表结构如下图所示：

可以看出环的入口结点为从头结点开始的第1个结点（注：头结点为第0个结点），所以输出true。
示例1
输入：{3,2,0,-4},1
返回值：true
说明：
第一部分{3,2,0,-4}代表一个链表，第二部分的1表示，-4到位置1（注：头结点为位置0），即-4->2存在一个链接，组成传入的head为一个带环的链表，返回true
示例2
输入：{1},-1
返回值：false
说明：
第一部分{1}代表一个链表，-1代表无环，组成传入head为一个无环的单链表，返回false
示例3
输入：{-1,-7,7,-4,19,6,-9,-5,-2,-5},6
返回值：true
思路
比较简单的想法是可以建立一个HashSet，依次遍历链表中的节点，若到某一步骤发现该节点已经在HashSet中，就代表有环，该节点就是入环节点

    public ListNode EntryNodeOfLoop(ListNode pHead) {
        HashSet<ListNode> nodeSet = new HashSet();
        ListNode cur = pHead;
        while(cur!=null){
            if(nodeSet.contains(cur)){
                return cur;
            }
            nodeSet.add(cur);
            cur = cur.next;
        }
        return null;
    }

上述思路虽然好理解也好编程，但是空间复杂度没有达到O(1)的方法。
针对此问题还有一个更好的解决方案：快慢指针方法。
可以这样理解，在针对链表做遍历时，一旦指针进入环中，便只能沿环运动。若环上有一快一慢两个指针，则根据追及问题的原理，一定会在某一时刻快的指针追赶上慢的指针。
若是链表无环，则快指针会在遍历过程中先行到达终点

public boolean hasCycle(ListNode head) {
         ListNode fastPtr=head;
         ListNode slowPtr = head;
         while(fastPtr!=null){
             fastPtr = fastPtr.next;
             if(fastPtr!=null){
                 fastPtr = fastPtr.next;
             }
             else{
                 return false;
             }
             slowPtr = slowPtr.next;
             if(fastPtr==slowPtr){
                 return true;
             }
         }
        return false;
    }

链表中环的入口结点

描述
给一个长度为n链表，若其中包含环，请找出该链表的环的入口结点，否则，返回null。

数据范围：0n≤10000，1<=结点值<=10000
要求：空间复杂度 O(1)，时间复杂度 O(n)

例如，输入{1,2},{3,4,5}时，对应的环形链表如下图所示：

可以看到环的入口结点的结点值为3，所以返回结点值为3的结点。
输入描述：
输入分为2段，第一段是入环前的链表部分，第二段是链表环的部分，后台会根据第二段是否为空将这两段组装成一个无环或者有环单链表
返回值描述：
返回链表的环的入口结点即可，我们后台程序会打印这个结点对应的结点值；若没有，则返回对应编程语言的空结点即可。
示例1
输入：{1,2},{3,4,5}
返回值：3
说明：返回环形链表入口结点，我们后台程序会打印该环形链表入口结点对应的结点值，即3
示例2
输入：{1},{}
返回值：“null”
说明：没有环，返回对应编程语言的空结点，后台程序会打印"null"
示例3
输入：{},{2}
返回值：2
说明：环的部分只有一个结点，所以返回该环形链表入口结点，后台程序打印该结点对应的结点值，即2
思路：
延续上题快慢指针的描述。经证明，当两指针初次相遇后，一个指针回到头结点处，两个指针均每次前进一个结点。两指针相遇的位置即为入环结点。

 public ListNode EntryNodeOfLoop(ListNode pHead) {
         ListNode fastPtr=pHead;
         ListNode slowPtr = pHead;
         while(fastPtr!=null){
             fastPtr = fastPtr.next;
             if(fastPtr!=null){
                 fastPtr = fastPtr.next;
             }
             else{
                 return null;
             }
             slowPtr = slowPtr.next;
             if(fastPtr==slowPtr){
                 fastPtr = pHead;
                 while(fastPtr!=slowPtr){
                     fastPtr = fastPtr.next;
                     slowPtr = slowPtr.next;
                 }
                 return fastPtr;
             }
         }
         return null;
     }

两个链表的第一个公共节点

描述
输入两个无环的单向链表，找出它们的第一个公共结点，如果没有公共节点则返回空。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）
数据范围： 0n≤1000
要求：空间复杂度 O(1)，时间复杂度O(n)
例如，输入{1,2,3},{4,5},{6,7}时，两个无环的单向链表的结构如下图所示：

可以看到它们的第一个公共结点的结点值为6，所以返回结点值为6的结点。
输入描述：
输入分为是3段，第一段是第一个链表的非公共部分，第二段是第二个链表的非公共部分，第三段是第一个链表和第二个链表的公共部分。 后台会将这3个参数组装为两个链表，并将这两个链表对应的头节点传入到函数FindFirstCommonNode里面，用户得到的输入只有pHead1和pHead2。
返回值描述：
返回传入的pHead1和pHead2的第一个公共结点，后台会打印以该节点为头节点的链表。
示例1
输入：{1,2,3},{4,5},{6,7}
返回值：{6,7}
说明：第一个参数{1,2,3}代表是第一个链表非公共部分，第二个参数{4,5}代表是第二个链表非公共部分，最后的{6,7}表示的是2个链表的公共部分
这3个参数最后在后台会组装成为2个两个无环的单链表，且是有公共节点的
示例2
输入：{1},{2,3},{}
返回值：{}
说明：2个链表没有公共节点 ,返回null，后台打印{}
思路
分析这道题，若两个链表相交，则不可能出现一个链表有环，一个链表无环的情况。
若两链表都无环，实际的结构应该是一个Y字型。可以遍历得到两个链表的长度。之后规定两个链表从短链表的开头位置做对比，若有某一后续节点相等且不为空，则代表两链表相交
若两链表都有环，有两种情况。一种情况是两链表在环外就已相交。一种情况是两链表有不同的入环节点，但共享一个环。对于这两种情况，首先都要获得两个链表的入环节点。若两链表的入环节点相等，代表是第一种情况。若不相等，从某一个入环节点开始遍历，若遍历途中遇到了另一入环节点，代表是第二种情况，若遍历遇到了该入环节点本身，代表两链表不相交。
代码

public class Solution {
     public ListNode EntryNodeOfLoop(ListNode pHead) {
         ListNode fastPtr=pHead;
         ListNode slowPtr = pHead;
         while(fastPtr!=null){
             fastPtr = fastPtr.next;
             if(fastPtr!=null){
                 fastPtr = fastPtr.next;
             }
             else{
                 return null;
             }
             slowPtr = slowPtr.next;
             if(fastPtr==slowPtr){
                 fastPtr = pHead;
                 while(fastPtr!=slowPtr){
                     fastPtr = fastPtr.next;
                     slowPtr = slowPtr.next;
                 }
                 return fastPtr;
             }
         }
         return null;
     }
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        ListNode Node1 = EntryNodeOfLoop(pHead1);
        ListNode Node2 = EntryNodeOfLoop(pHead2);
        if(Node1!=Node2){
            if(Node1==null||Node2==null){
                //两链表一个有环一个无环的情况
                return null;
            }
            else{
                //两链表入环节点不同的情况
                ListNode cur = Node1;
                while(cur!=Node2){
                    cur=cur.next;
                    if(cur==Node1){
                        return null;
                    }
                }
                return Node1;
            }
        }
        else{
            if (Node1!=null){
                //两个入环节点相同的有环链表的情况
                return Node1;
            }
            else{
                //两个无环链表的情况
                int len1=0;
                int len2=0;
                ListNode cur = pHead1;
                while(cur!=null){
                    len1++;
                    cur=cur.next;
                }
                cur =pHead2;
                 while(cur!=null){
                    len2++;
                    cur=cur.next;
                }
                ListNode ptr1=pHead1;
                ListNode ptr2=pHead2;
                if(len1>len2){
                    int gap = len1-len2;
                    for (int i=0;i<gap;i++){
                        ptr1=ptr1.next;
                    }
                }
                else{
                     int gap = len2-len1;
                    for (int i=0;i<gap;i++){
                        ptr2=ptr2.next;
                    }
                }
                while(ptr1!=null){
                    if(ptr1==ptr2){
                        return ptr1;
                    }
                    ptr1=ptr1.next;
                    ptr2=ptr2.next;
                }
                    return null;
                }
            }
    }
}

(因为没有找到该问题的OJ，该代码只经过了自己生成的数据的测试，不过大体思路应该问题不大）

两个无环链表是否相交

之前我做这个题的思路只有哈希表和计算长度然后让一个指针先走。今天看labuladong的博客学习了另一种方法，也是O(n)的时间复杂度就可以判断。

以下引用自https://labuladong.gitee.io/algo/2/18/17/
原链表：> 这里是如果用两个指针 p1 和 p2 分别在两条链表上前进，并不能同时走到公共节点，也就无法得到相交节点 c1。 解决这个问题的关键是，通过某些方式，让 p1 和 p2 能够同时到达相交节点 c1。所以，我们可以让 p1 遍历完链表 A 之后开始遍历链表 B，让 p2 遍历完链表 B 之后开始遍历链表 A，这样相当于「逻辑上」两条链表接在了一起。如果这样进行拼接，就可以让 p1 和 p2 同时进入公共部分，也就是同时到达相交节点 c1：

代码：

ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    // p1 指向 A 链表头结点，p2 指向 B 链表头结点
    ListNode p1 = headA, p2 = headB;
    while (p1 != p2) {
        // p1 走一步，如果走到 A 链表末尾，转到 B 链表
        if (p1 == null) p1 = headB;
        else            p1 = p1.next;
        // p2 走一步，如果走到 B 链表末尾，转到 A 链表
        if (p2 == null) p2 = headA;
        else            p2 = p2.next;
    }
    return p1;

文中还提到了另一巧妙地方法：

如果把两条链表首尾相连，那么「寻找两条链表的交点」的问题转换成了前面讲的「寻找环起点」的问题：