【NO.51】LeetCode HOT 100—142. 环形链表 II

最新推荐文章于 2024-07-21 08:37:44 发布

悬浮海

最新推荐文章于 2024-07-21 08:37:44 发布

阅读量371

点赞数 8

分类专栏： # LeetCode HOT 100 文章标签： leetcode 链表算法 142. 环形链表 II

本文链接：https://blog.csdn.net/wang_luwei/article/details/136750842

版权

LeetCode HOT 100 专栏收录该内容

101 篇文章 1 订阅

订阅专栏

本文介绍了如何使用快慢指针和哈希表的方法解决环形链表II问题，即在给定链表中找到第一个环的入口节点。两种方法的时间复杂度均为O(n)，但空间复杂度不同：快慢指针为O(1)，哈希表为O(n)。

摘要由CSDN通过智能技术生成

文章目录

142. 环形链表 II

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改链表。

示例 1：

在这里插入图片描述

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：
在这里插入图片描述

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：
在这里插入图片描述

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

提示：

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

进阶：你是否可以使用 O(1) 空间解决此题？

解题

方法一：快慢指针

时间O（n），空间O（1）

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    /**
        slow * 2 = fast;
        slow = a + b;
        fast = a + b + c + b = a + 2*b + c;
        (a + b)*2 = a + 2*b + c;
        a = c;
    
        所以第一次相遇之后，让fast=head，slow不变，再相遇时就是入口
     */
    public ListNode detectCycle(ListNode head) {
        // 链表为空，或只有一个节点
        if (head == null || head.next ==null) {
            return null;
        }
        // 注意两个是同起点
        ListNode fast = head;
        ListNode slow = head;
        while (true) {
            // 无环
            if (fast.next == null || fast.next.next == null) {
                return null;
            }
            // 移动
            fast = fast.next.next;
            slow = slow.next;
            // 第一次相遇
            if (fast == slow) {
                break;
            }
        }

        // 准备第二次相遇 
        fast = head;
        while (fast != slow) {
            fast= fast.next;
            slow = slow.next;
        }
        // 第二次相遇时，就是入口
        return fast;

    }
}

方法二：哈希表

时间O（n），空间O（n）

/**
 * 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) {
        // HashMap，key为节点，value为下标
        // 链表为空，或只有一个节点
        if (head == null || head.next == null) {
            return null;
        }

        HashMap<ListNode, Integer> map = new HashMap<>();
        Integer index = 0;
        ListNode cur = head;
        while (cur != null) {
            // key重复，说明有环，并且也是要找的入环的第一个节点
            if (map.containsKey(cur)) {
                return cur;
            }
            map.put(cur, index);
            index++;
            cur = cur.next;
        }
        
        return null;
    }
}