剑指offer面试题23(java版):链表中环的入口节点

welcome to my blog

剑指offer面试题23(java版):链表中环的入口节点

题目描述

给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

思路(和寻找倒数第K个节点的思路有类似)

• 先判断是否有环
• 有环的话再判断环中的节点个数
• 利用类似"链表中倒数第K个节点"的思路找到环的入口

笔记

• 判断是否有环时, 需要创建两个指针, fast, slow. 其中,fast一次走两步, slow一次走一步. 如果fast能和slow相遇则说明链表中有环. 判断是否有环的原则可以证明
• 设,fast,slow相遇(没有限制是第一次相遇)时的移动次数为t, 相遇地点距离pHead为x, 环中的节点个数为n, fast在环中走过的圈数是k, slow在环中走过的圈数是l, 那么两指针相遇时满足: 2t - kn = x - ln, 推出 t = (k-l)n
• t有解析解, 说明fast和slow一定可以相遇. t能取任意多的值是因为可以相遇任意次
• 进一步明确限制:设pHead到环入口节点相差e个节点, 如果k>0的话, 说明fast走过的长度满足2t - e - kn >= 0, 推出t >= (e+kn)/2
• 举个例子: 可以令n=8, e=6, k=1, k=1, l=0, 得出t = 8
• 这里再证明一个问题, 有没有可能slow转一圈之后再和fast第一次相遇? 有, 比如e=0,n=2时,fast和slow在第二轮相遇
• 遗留问题: slow和fast有没有可能在环中不能相遇?

笔记

先对变量做出改变还是先进行if判断, 一定要想清楚

                for(int i=0; i<stepCount; i++){
                    if(fast==slow)
                        return slow;
                    fast = fast.next;
                    slow = slow.next;

第二次做, 来一个不严谨的证明, 倒推

以head为参考点, 初始时慢指针指向head, 快指针指向head.next, 慢指针一次走一步, 快指针一次走两步

假设慢指针走t步后和快指针相遇, 此时慢指针距离head的距离是t, 快指针距离head的距离是2t+1, 设环中节点个数为n, 那么有2t+1-n=t, 可以得到t = n-1

此时令慢指针指向head, 快指针指向当前节点你的下一个节点, 现在起快慢指针一次走一步, 走x步后慢指针距离head的距离为x, 快指针距离head为2t+1+1+x = 2t+2+x, 代入t=n-1得快指针距离head为2n+x,说明快指针在环中刚好走了两圈, 去掉环的距离后,快指针距离head为x, 和慢指针的结果相同, 所以二者相遇, 这就是为什么代码中right = right.next, 然后再让快慢指针一起走

/*
先判断有没有环
有环的话再找出环的入口节点
*/
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        //先判断有没有环；一个节点不能行成环
        if(pHead==null || pHead.next==null)
            return null;
        ListNode left=pHead, right=pHead.next;
        while(left!=right){
            //带环的链表不会有指向null的指针
            if(right==null || right.next==null)
                return null;
            //更新指针
            left = left.next;
            right = right.next.next;
        }
        //寻找环的入口节点
        left = pHead;
        right = right.next;//这个赋值很关键, right必须向后移动一步
        while(left != right){
            left = left.next;
            right = right.next;
        }
        return left;
    }
}

public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        // input check 
        if(pHead == null)
            return null;
        // execute
        /*
        1. 判断链表是否有环
            1.1无环: 返回false
            1.2有环: 获取环中的节点个数
                1.2.1找到环的入口节点
        */
        //1.1
        int loopCount = hasLoop(pHead);
        if(loopCount == 0)
            return null;
        //1.2.1
        ListNode fast = pHead;
        ListNode slow = pHead;
        for(int i=0; i<loopCount; i++)
            fast = fast.next;
        while(fast != slow){
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
    public int hasLoop(ListNode pHead){
        // 0 代表无环, 大于零表示环中节点的数量
        //input check
        if(pHead==null || pHead.next == null) //一个节点无法成环
            return 0;
        //
        // execute
        ListNode fast = pHead;
        ListNode slow = pHead;
        while(fast != null){
            if(fast.next.next != null){
                fast = fast.next.next;
                slow = slow.next;
            }
            else{
                return 0;
            }
            if( fast == slow){
                // 有环, 统计环中节点数量
                int loopCount = 1; //注意计数起始值, 注意环中节点的计数方式
                fast = fast.next;
                while(fast != slow){
                    loopCount++;
                    fast = fast.next;
                }
                return loopCount;
            }
        }
        return 0;
    }
}

进阶版代码(利用数学分析)

思路

• 判断是否有环
• 2s - kn = s -ln, 推出s = (k-l)n, 意味着fast和slow相遇时,移动的次数等于环中节点的整数倍
• 如果在相遇处, fast再走s步, 每次走一个节点, 同时slow从pHead开始再走s步, 每次走一个节点. 那么fast和slow还会再次相遇
• 上面这个过程等价于fast,slow从pHead出发, fast每次走俩节点, slow走一个节点, 然后走s步之后相遇
• 只不过上面的过程中,fast和slow每次都走一个节点,所以fast和slow一定在环的入口节点处就相遇了

public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        // input check 
        if(pHead == null || pHead.next == null)
            return null;
        // execute
        /*
        假设链表有环, fast,slow起初都指向pHead, fast一次走两步, slow一次走一步
        设移动t次后fast和slow第一次相遇,第一次相遇的特点是:fast可能在环中转了好几圈, 至少是一圈. 相遇地点距离pHead是x
        移动步数满足2s - kn = s - ln
        s = (k-l)n
        s是n的整数倍
        相当于寻找链表中倒数第s个节点, 为了便于理解, 把(k-l)个环展平
        */
        // 判断是否有环
        ListNode fast = pHead;
        ListNode slow = pHead;
        int stepCount = 0;
        while(fast.next != null){
            fast = fast.next.next; // 只有fast.next不为null, fast.next才有next
            slow =slow.next;
            stepCount++;
            if(fast == slow){
                slow = pHead;
                for(int i=0; i<stepCount; i++){
                    if(fast==slow)
                        return slow;
                    fast = fast.next;
                    slow = slow.next;
                }
            }
        }
        return null;
    }
}