leetcode
leetcode 251 ~ 300
寻找重复数

寻找重复数

难度:

标签:

题目描述

给定一个包含 n + 1 个整数的数组 nums ,其数字都在 [1, n] 范围内(包括 1n),可知至少存在一个重复的整数。

假设 nums 只有 一个重复的整数 ,返回 这个重复的数

你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。

 

示例 1:

输入:nums = [1,3,4,2,2]
输出:2

示例 2:

输入:nums = [3,1,3,4,2]
输出:3

示例 3 :

输入:nums = [3,3,3,3,3]
输出:3

 

 

提示:

  • 1 <= n <= 105
  • nums.length == n + 1
  • 1 <= nums[i] <= n
  • nums只有一个整数 出现 两次或多次 ,其余整数均只出现 一次

 

进阶:

  • 如何证明 nums 中至少存在一个重复的数字?
  • 你可以设计一个线性级时间复杂度 O(n) 的解决方案吗?

代码结果

运行时间: 40 ms, 内存: 0.0 MB


// 思路:虽然使用Java Stream API不太适合这个问题,因为我们要求的O(1)空间复杂度和不修改数组的要求。但我们可以用stream API来验证思路。
// 我们依然使用快慢指针的方法来找到重复的数字。
// Java Stream本质上是函数式编程,在这里我们将其当做一种练习。
 
import java.util.stream.IntStream;
 
public class Solution {
    public int findDuplicate(int[] nums) {
        // 初始化慢指针和快指针
        int slow = nums[0];
        int fast = nums[0];
        // 找到第一个相遇点
        do {
            slow = nums[slow];
            fast = nums[nums[fast]];
        } while (slow != fast);
        // 找到入口
        slow = nums[0];
        while (slow != fast) {
            slow = nums[slow];
            fast = nums[fast];
        }
        return slow;
    }
}

解释

方法:

这个题解利用了Floyd的乌龟和兔子(循环检测)算法,来寻找重复的数。该算法使用两个指针,一个快指针(兔子)和一个慢指针(乌龟),快指针每次移动两步,慢指针每次移动一步。如果存在一个循环,快指针最终会追上慢指针。这一部分用来检测循环,就像检测链表中的环。一旦快慢指针相遇,就确定了循环的存在,然后使用两个新的指针,一个从头开始,另一个从相遇点开始,每次各走一步,当它们相遇时,就是循环的起点,也就是重复的数。

时间复杂度:

O(n)

空间复杂度:

O(1)

代码细节讲解

🦆
为什么Floyd的乌龟和兔子算法适用于这个问题,尽管数组nums并不是一个标准的链表结构?
尽管数组nums并不是一个标准的链表结构,但数组中的元素可以看作是指向数组中其他位置的指针(即元素值指向数组的索引)。由于题目中存在重复数字,这将导致至少有一个数字被多个索引指向,形成一个环。这样的结构与链表中的环相似,因此可以使用Floyd的乌龟和兔子算法来检测和找到这个环,进而确定重复的数字。
🦆
在算法中,快指针每次移动两步,慢指针每次移动一步的原因是什么?这种设置对算法的效率有何影响?
快指针每次移动两步,慢指针每次移动一步的设置是为了确保如果存在环,快指针可以追上慢指针,从而证明环的存在。这种设置增加了检测环的效率,因为快指针移动得更快,可以更早地发现环的存在或确认环不存在,从而减少了算法的总体执行时间。
🦆
当快慢指针第一次相遇时,如何确保此点确实在循环中,而不是仅仅是因为随机走到了同一个位置?
在Floyd的算法中,如果快慢指针在非环形结构中移动,则它们永远不会相遇;它们只有在存在环的情况下才会相遇。这是因为快指针每次都跳过了一个节点,如果没有环,它会先到达数组的尽头。只有当存在环,快指针才会绕环运动并最终追上慢指针,从而证明循环确实存在。
🦆
寻找循环起点的过程中,为什么将一个新指针从数组的起点开始,同时另一个从快慢指针相遇的地方开始,它们相遇的点就是重复的数?
根据数学证明和Floyd算法的性质,从数组起点到环起点的距离等于从快慢指针相遇点到环起点的距离。因此,当一个指针从数组起点开始,另一个从相遇点开始,它们以相同速度移动时会在环的起点相遇。由于环的形成是由于数字的重复,所以这个相遇点即为重复的数。

相关问题

缺失的第一个正数

给你一个未排序的整数数组 nums ,请你找出其中没有出现的最小的正整数。

请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。

 

示例 1:

输入:nums = [1,2,0]
输出:3
解释:范围 [1,2] 中的数字都在数组中。

示例 2:

输入:nums = [3,4,-1,1]
输出:2
解释:1 在数组中,但 2 没有。

示例 3:

输入:nums = [7,8,9,11,12]
输出:1
解释:最小的正数 1 没有出现。

 

提示:

  • 1 <= nums.length <= 105
  • -231 <= nums[i] <= 231 - 1

只出现一次的数字

给你一个 非空 整数数组 nums ,除了某个元素只出现一次以外,其余每个元素均出现两次。找出那个只出现了一次的元素。

你必须设计并实现线性时间复杂度的算法来解决此问题,且该算法只使用常量额外空间。

 

示例 1 :

输入:nums = [2,2,1]
输出:1

示例 2 :

输入:nums = [4,1,2,1,2]
输出:4

示例 3 :

输入:nums = [1]
输出:1

 

提示:

  • 1 <= nums.length <= 3 * 104
  • -3 * 104 <= nums[i] <= 3 * 104
  • 除了某个元素只出现一次以外,其余每个元素均出现两次。

环形链表 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, 104]
  • -105 <= Node.val <= 105
  • pos 的值为 -1 或者链表中的一个有效索引

 

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

丢失的数字

给定一个包含 [0, n] 中 n 个数的数组 nums ,找出 [0, n] 这个范围内没有出现在数组中的那个数。

 

示例 1:

输入:nums = [3,0,1]
输出:2
解释:n = 3,因为有 3 个数字,所以所有的数字都在范围 [0,3] 内。2 是丢失的数字,因为它没有出现在 nums 中。

示例 2:

输入:nums = [0,1]
输出:2
解释:n = 2,因为有 2 个数字,所以所有的数字都在范围 [0,2] 内。2 是丢失的数字,因为它没有出现在 nums 中。

示例 3:

输入:nums = [9,6,4,2,3,5,7,0,1]
输出:8
解释:n = 9,因为有 9 个数字,所以所有的数字都在范围 [0,9] 内。8 是丢失的数字,因为它没有出现在 nums 中。

示例 4:

输入:nums = [0]
输出:1
解释:n = 1,因为有 1 个数字,所以所有的数字都在范围 [0,1] 内。1 是丢失的数字,因为它没有出现在 nums 中。

 

提示:

  • n == nums.length
  • 1 <= n <= 104
  • 0 <= nums[i] <= n
  • nums 中的所有数字都 独一无二

 

进阶:你能否实现线性时间复杂度、仅使用额外常数空间的算法解决此问题?

错误的集合

集合 s 包含从 1 到 n 的整数。不幸的是,因为数据错误,导致集合里面某一个数字复制了成了集合里面的另外一个数字的值,导致集合 丢失了一个数字 并且 有一个数字重复

给定一个数组 nums 代表了集合 S 发生错误后的结果。

请你找出重复出现的整数,再找到丢失的整数,将它们以数组的形式返回。

 

示例 1:

输入:nums = [1,2,2,4]
输出:[2,3]

示例 2:

输入:nums = [1,1]
输出:[1,2]

 

提示:

  • 2 <= nums.length <= 104
  • 1 <= nums[i] <= 104