算法经典题：判断链表中是否有环以及环的入口位置

最新推荐文章于 2024-08-24 23:59:08 发布

多拿好offer

最新推荐文章于 2024-08-24 23:59:08 发布

阅读量289

点赞数

分类专栏：算法文章标签：链表算法

本文链接：https://blog.youkuaiyun.com/qq_41358366/article/details/121789054

版权

算法专栏收录该内容

42 篇文章

订阅专栏

NC4 判断链表中是否有环

判断给定的链表中是否有环。如果有环则返回true，否则返回false。

数据范围：链表长度 $0 \le n \le 10000$ ，链表中任意节点的值满足 $|val| \le 100000$

要求：空间复杂度 $O(1)$ ，时间复杂度 $O(n)$

思路1：哈希表（时空复杂度都是 $O(n)$ ）:遍历链表，把每个节点存入哈希表，当出现重复的节点时，说明有环

import java.util.*;
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        Set<ListNode> set = new HashSet<>();
        while(head != null) {
            if(set.contains(head)) {
                return true;
            }
            set.add(head);
            head = head.next;
        }
        return false;
    }
}

思路2：快慢指针(时间复杂度 $O(n)$ ，空间复杂度 $O(1)$ )：慢指针每次走一步，快指针每次走两步，如果存在环的话，那么快慢指针会再次相遇，否则快指针会先走到null

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null) {
            return false;
        }
        ListNode slow = head,fast = head;
        while(fast != null) {
            slow = slow.next;
            fast = fast.next;
            if(fast == null) {
                return false;
            } else {
                fast = fast.next;
            }
            if(slow == fast) {
                return true;
            }
        }
        return false;
    }
}

剑指 Offer II 022. 链表中环的入口节点

给定一个链表，返回链表开始入环的第一个节点。从链表的头节点开始沿着next指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

说明：不允许修改给定的链表。

提示：

链表中节点的数目范围在范围 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引

思路1：哈希表（时空复杂度都是 $O(n)$ ）：遍历每个节点，当哈希表中存在某个指针时，那么存在环，且环的入口就是这个节点，所以直接返回这个节点即可。当遍历到空节点，说明不存在环，此时返回null即可

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        Set<ListNode> set = new HashSet<>();
        while(head != null) {
            if(set.contains(head)) {
                return head;
            }
            set.add(head);
            head = head.next;
        }
        return null;
    }
}

思路2：快慢指针（时间复杂度为 $O(n)$ ，空间复杂度为 $O(1)$ ）：慢指针每次走一步，快指针每次都两步，如果快指针走到null说明不存在环，直接返回null。否则快慢指针会相遇，标记相遇点为c，起始点为a，环入口节点为b，定义ab距离为x，bc距离为y，那么此时慢指针走了x+y步，快指针走了x+y+n*L，L是环的长度。所以存在2(x+y)=x+y+n*L。所以x=n*L-y。观察这个等式可以发现，当指针从起始点走x步走到环入口时，另一个指针可以在相遇点走n*L-y步走到环入口。所以当快慢指针相遇后，slow回到起始点，fast在相遇点，两者以相同速度走，会在环入口相遇。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head, fast = head;
        while(fast != null) {
            slow = slow.next;
            fast = fast.next;
            if(fast == null) {
                return null;
            }
            fast = fast.next;
            if(slow == fast) {     // 相遇点
                break;
            }
        }
        if(fast == null) {
            return null;
        }
        slow = head;
        while(slow != fast) {     // slow从起点走，fast从相遇点走，以相同速度，两者会在环入口相遇
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}