有环链表问题总结

一、什么是叫做链表有环？

当一个链表没有环时，我们可以直接从链表的头遍历到链表的尾部，而当一个链表有环时，链表会在环中一直旋转。如下图所示:

这个单链表即存在一个环，3、4、5、6，环的入口为3。

二、如何判断一个链表是否有环？

判断一个链表是否有环，我这里提两种方法，比较常用的是第二种

1.使用哈希表实现

将单链表中的节点元素一个一个放入哈希表（set）中，如果当前放入的节点在哈希表里存在，说明在当前节点之前有和其相同的节点，这样就可以说链表有环，如果遍历到最后都没有重复的节点出现。

Python:

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        if (head == None):
            return False
        # 创建一个集合
        set1 = set()
        while (head != None):
            if (head in set1):
                return True
            set1.add(head)
            head = head.next
        return False

JAVA:

public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null)
            return false;
        // 使用哈希表来做
        HashSet<ListNode> set = new HashSet<ListNode>();
        while(head != null){
            if (set.contains(head))
                // 如果之前在前面有当前节点，那么说明链表有环
                return true;
            set.add(head);
            head = head.next;
        }
        return false;
    }
}

2.快慢指针实现方法

假设有两个指针，第一个指针每次移动一位称为慢指针，第二个指针每次移动两位称为快指针，那么如果链表是有环的快慢指针终将相遇，而且假如快慢指针相遇，假设慢指针移动了x步，那么快指针就移动了2x步，而快指针是在慢指针之后走了n（环的大小）与慢指针相遇的，由此2x=x+n，x = n，也就是说，在快慢指针相遇时，慢指针恰好走了n（环的大小）步。

JAVA:

public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null){
            return false;
        }
        // 定义慢指针
        ListNode slowNode = head;
        // 定义快指针
        ListNode fastNode = head;
        while (fastNode != null && fastNode.next != null){
            slowNode = slowNode.next;
            fastNode = fastNode.next.next;
            if (slowNode == fastNode){
                return true;
            }
        }
        return false;
        
    }
}

Python

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        # 使用快慢指针来解决
        slow = head
        fast = head
        while fast != None and fast.next != None:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                return True
        return False
            

快慢指针是链表问题的很常用的方法，同时也很好理解。

三、如何找到链表环的入口？

首先要判断链表是否有环，之后我们上面提到了，当快慢指针相遇时，慢指针正好前进了n（步），如上图，快慢指针会相遇在5节点上，那么这时让快指针回到头节点上，之后快慢指针以相同速度前进，相遇的点就是入口。

加入链表长度为l，环的大小为n，那么快指针回到头结点后需要走l-n步回到入口节点，慢节点也需要同样的步数才能达到入口。

JAVA

public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead) {
        if (pHead == null)
            return null;
        ListNode p1 = pHead, p2 = pHead;
        while (p2 != null && p2.next != null) {
            p1 = p1.next;
            p2 = p2.next.next;
            //当快慢指针相遇时
            if (p1 == p2) {
                // 让快指针回到链表头结点
                p2 = pHead;
                while (p1 != p2) {
                    // 两个指针以相同的速度移动
                    p1 = p1.next;
                    p2 = p2.next;
                }
                if (p1 == p2)
                    return p1;
            }
        }
        return null;
    }
}

Python

class Solution:
    def EntryNodeOfLoop(self, pHead):
        # write code here
        if not pHead or not pHead.next or not pHead.next.next:
            return None
        slow = pHead.next
        fast = slow.next
        # 找到相遇点
        while fast != slow and fast.next:
            slow = slow.next
            fast = fast.next.next
        if slow == fast:
            # 慢指针回到表头，快指针留在相遇点，二者同步往前直到相遇在入口结点
            slow = pHead
            while slow != fast:
                fast = fast.next
                slow = slow.next
            return slow
        return None

四、如何找到两个链表的第一个公共节点？

这是一个比较巧妙地题

[3 7 8 4 5 6] 和[1 2 3 4 5 6]两个链表的第一个公共节点是4，这里需要注意公共链表指的是节点的地址相同，而非大小相同就相同，你看着一样但在计算机里两个节点是不一样的。这个问题其实可以通过，将链表的尾节点与其中一个链表的头节点相连，这样就构成了有环链表，问题自然就变成了环入口问题。如上图我们将6与第一个链表头结点3相连。

也就是在求环的入口节点问题的解决方法上多加了一步，让尾节点与其中一个链表头相连

class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode last = headB;
        while (last.next != null) {
            last = last.next;
        }
        last.next = headB;

        ListNode fast = headA;
        ListNode slow = headA;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                slow = headA;
                while (slow != fast) {
                    slow = slow.next;
                    fast = fast.next;
                }
                last.next = null;
                return fast;
            }
        }
        last.next = null;
        return null;
    }
}

这个问题还有另一种解决办法，想了解的话可以参考《剑指Offer》