牛客题解 | 缺失的第一个正整数

原创已于 2025-03-07 10:18:00 修改 · 452 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #力扣 #面试 #算法力扣

于 2025-03-07 10:17:26 首次发布

牛客面试必刷101题单题解专栏收录该内容

103 篇文章

订阅专栏

题目## 题目

题目链接

题目主要信息:

题目给定一个无序整型数组，没有重复元素，可能有负数或零，需要找出其中没有出现的最小正整数

举一反三：

学习完本题的思路你可以解决如下题目：

BM51. 数组中出现次数超过一半的数字

BM52. 数组中只出现一次的两个数字

方法一：哈希表（推荐使用）

知识点：哈希表

哈希表是一种根据关键码（key）直接访问值（value）的一种数据结构。而这种直接访问意味着只要知道key就能在 $O (1)$ 时间内得到value，因此哈希表常用来统计频率、快速检验某个元素是否出现过等。

思路：

$n$ 个长度的数组，没有重复，则如果数组填满了 $1 ～ n$ ，那么缺失 $n + 1$ ，如果数组填不满 $1 ～ n$ ，那么缺失的就是 $1 ～ n$ 中的数字。对于这种快速查询某个元素是否出现过的问题，还是可以使用哈希表快速判断某个数字是否出现过。

具体做法：

step 1：构建一个哈希表，用于记录数组中出现的数字。
step 2：从1开始，遍历到n，查询哈希表中是否有这个数字，如果没有，说明它就是数组缺失的第一个正整数，即找到。
step 3：如果遍历到最后都在哈希表中出现过了，那缺失的就是n+1.

Java实现代码：

import java.util.*;
public class Solution {
    public int minNumberDisappeared (int[] nums) {
        int n = nums.length;
        HashMap<Integer, Integer> mp = new HashMap<Integer, Integer>(); 
        //哈希表记录数组中出现的每个数字
        for(int i = 0; i < n; i++) 
            mp.put(nums[i], 1);
        int res = 1;
        //从1开始找到哈希表中第一个没有出现的正整数
        while(mp.containsKey(res)) 
            res++;
        return res;
    }
}

C++实现代码：

class Solution {
public:
    int minNumberDisappeared(vector<int>& nums) {
        int n = nums.size();
        unordered_map<int, int> mp;
        //哈希表记录数组中出现的每个数字
        for(int i = 0; i < n; i++) 
            mp[nums[i]]++;
        int res = 1;
        //从1开始找到哈希表中第一个没有出现的正整数
        while(mp.find(res) != mp.end()) 
            res++;
        return res;
    }
};

Python实现代码：

class Solution:
    def minNumberDisappeared(self , nums: List[int]) -> int:
        n = len(nums)
        mp = dict()
        #哈希表记录数组中出现的每个数字
        for i in range(n): 
            if nums[i] in mp:
                mp[nums[i]] += 1
            else:
                mp[nums[i]] = 1
        res = 1
        #从1开始找到哈希表中第一个没有出现的正整数
        while res in mp: 
            res += 1
        return res

复杂度分析：

时间复杂度： $O (n)$ ，第一次遍历数组，为 $O (n)$ ，第二次最坏从1遍历到 $n$ ，为 $O (n)$
空间复杂度： $O (n)$ ，哈希表记录 $n$ 个不重复的元素，长度为 $n$

方法二：原地哈希（扩展思路）

思路：

前面提到了数组要么缺失 $1 ～ n$ 中的某个数字，要么缺失 $n + 1$ ，而数组正好有下标 $0 ～ n - 1$ 可以对应数字 $1 ～ n$ ，因此只要数字 $1 ～ n$ 中某个数字出现，我们就可以将对应下标的值做一个标记，最后没有被标记的下标就是缺失的值。

具体做法：

step 1：我们可以先遍历数组将所有的负数都修改成n+1。
step 2：然后再遍历数组，每当遇到一个元素绝对值不超过n时，则表示这个元素是1～n中出现的元素，我们可以将这个数值对应的下标里的元素改成负数，相当于每个出现过的正整数，我们把与它值相等的下标都指向一个负数，这就是类似哈希表的实现原理的操作。
step 3：最后遍历数组的时候碰到的第一个非负数，它的下标就是没有出现的第一个正整数，因为它在之前的过程中没有被修改，说明它这个下标对应的正整数没有出现过。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java实现代码：

import java.util.*;
public class Solution {
    public int minNumberDisappeared (int[] nums) {
        int n = nums.length;
        //遍历数组
        for(int i = 0; i < n; i++) 
            //负数全部记为n+1
            if(nums[i] <= 0) 
                nums[i] = n + 1;
        for(int i = 0; i < n; i++)
            //对于1-n中的数字
            if(Math.abs(nums[i]) <= n) 
                //这个数字的下标标记为负数
                nums[Math.abs(nums[i]) - 1] = -1 * Math.abs(nums[Math.abs(nums[i]) - 1]); 
        for(int i = 0; i < n; i++)
            //找到第一个元素不为负数的下标
            if(nums[i] > 0)
                return i + 1;
        return n + 1;
    }
}

C++实现代码：

class Solution {
public:
    int minNumberDisappeared(vector<int>& nums) {
        int n = nums.size();
        //遍历数组
        for(int i = 0; i < n; i++) 
            //负数全部记为n+1
            if(nums[i] <= 0) 
                nums[i] = n + 1;
        for(int i = 0; i < n; i++)
            //对于1-n中的数字
            if(abs(nums[i]) <= n) 
                //这个数字的下标标记为负数
                nums[abs(nums[i]) - 1] = -1 * abs(nums[abs(nums[i]) - 1]); 
        for(int i = 0; i < n; i++)
            //找到第一个元素不为负数的下标
            if(nums[i] > 0)
                return i + 1;
        return n + 1;
    }
};

Python实现代码：

class Solution:
    def minNumberDisappeared(self , nums: List[int]) -> int:
        n = len(nums)
        #遍历数组
        for i in range(n): 
            #数全部记为n+1
            if nums[i] <= 0: 
                nums[i] = n + 1
        for i in range(n):
            #对于1-n中的数字
            if abs(nums[i]) <= n: 
                #这个数字的下标标记为负数
                nums[abs(nums[i]) - 1] = -1 * abs(nums[abs(nums[i]) - 1]) 
        for i in range(n):
            #找到第一个元素不为负数的下标
            if nums[i] > 0: 
                return i + 1
        return n + 1

复杂度分析：

时间复杂度： $O (n)$ ，多次遍历数组，都是单层循环
空间复杂度： $O (1)$ ，原地哈希，以索引为指向，没有额外空间

题目链接

题目主要信息:

给定两个长度可能不同的字符串，可以对第一个字符串增删改字符
求增删改的最少次数，让第一个字符串变成第二个字符串
字符串中只出现大小写字母

举一反三：

学习完本题的思路你可以解决如下题目：

方法：动态规划（推荐使用）

知识点：动态规划

动态规划算法的基本思想是：将待求解的问题分解成若干个相互联系的子问题，先求解子问题，然后从这些子问题的解得到原问题的解；对于重复出现的子问题，只在第一次遇到的时候对它进行求解，并把答案保存起来，让以后再次遇到时直接引用答案，不必重新求解。动态规划算法将问题的解决方案视为一系列决策的结果

思路：

把第一个字符串变成第二个字符串，我们需要逐个将第一个字符串的子串最少操作下变成第二个字符串，这就涉及了第一个字符串增加长度，状态转移，那可以考虑动态规划。用dp[i][j]表示从两个字符串首部各自到str1[i]和str2[j]为止的子串需要的编辑距离，那很明显dp[str1.length][str2.length]就是我们要求的编辑距离。（下标从1开始）

具体做法：

step 1：初始条件： 假设第二个字符串为空，那很明显第一个字符串子串每增加一个字符，编辑距离就加1，这步操作是删除；同理，假设第一个字符串为空，那第二个字符串每增加一个字符，编剧距离就加1，这步操作是添加。
step 2：状态转移： 状态转移肯定是将dp矩阵填满，那就遍历第一个字符串的每个长度，对应第二个字符串的每个长度。如果遍历到str1[i]和 str2[j]的位置，这两个字符相同，这多出来的字符就不用操作，操作次数与两个子串的前一个相同，因此有 $d p [i] [j] = d p [i - 1] [j - 1]$ ；如果这两个字符不相同，那么这两个字符需要编辑，但是此时的最短的距离不一定是修改这最后一位，也有可能是删除某个字符或者增加某个字符，因此我们选取这三种情况的最小值增加一个编辑距离，即 $d p [i] [j] = min (d p [i - 1] [j - 1], min (d p [i - 1] [j], d p [i] [j - 1])) + 1$ 。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java实现代码：

import java.util.*;
public class Solution {
    public int editDistance (String str1, String str2) {
        int n1 = str1.length();
        int n2 = str2.length();
        //dp[i][j]表示到str1[i]和str2[j]为止的子串需要的编辑距离
        int[][] dp = new int[n1 + 1][n2 + 1]; 
        //初始化边界
        for(int i = 1; i <= n1; i++) 
            dp[i][0] = dp[i - 1][0] + 1;
        for(int i = 1; i <= n2; i++)
            dp[0][i] = dp[0][i - 1] + 1;
        //遍历第一个字符串的每个位置
        for(int i = 1; i <= n1; i++) 
            //对应第二个字符串每个位置
            for(int j = 1; j <= n2; j++){ 
                //若是字符相同，此处不用编辑
                if(str1.charAt(i - 1) == str2.charAt(j - 1)) 
                    //直接等于二者前一个的距离
                    dp[i][j] = dp[i - 1][j - 1]; 
                else
                    //选取最小的距离加上此处编辑距离1
                    dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i - 1][j], dp[i][j - 1])) + 1; 
            }
        return dp[n1][n2]; 
    }
}

C++实现代码：

class Solution {
public:
    int editDistance(string str1, string str2) {
        int n1 = str1.length();
        int n2 = str2.length();
        //dp[i][j]表示到str1[i]和str2[j]为止的子串需要的编辑距离
        vector<vector<int> > dp(n1 + 1, vector<int>(n2 + 1, 0)); 
        //初始化边界
        for(int i = 1; i <= n1; i++) 
            dp[i][0] = dp[i - 1][0] + 1;
        for(int i = 1; i <= n2; i++)
            dp[0][i] = dp[0][i - 1] + 1;
        //遍历第一个字符串的每个位置
        for(int i = 1; i <= n1; i++) 
            //对应第二个字符串每个位置
            for(int j = 1; j <= n2; j++){ 
                //若是字符相同，此处不用编辑
                if(str1[i - 1] == str2[j - 1]) 
                    //直接等于二者前一个的距离
                    dp[i][j] = dp[i - 1][j - 1]; 
                else
                    //选取最小的距离加上此处编辑距离1
                    dp[i][j] = min(dp[i - 1][j - 1], min(dp[i - 1][j], dp[i][j - 1])) + 1; 
            }
        return dp[n1][n2]; 
    }
};

Python代码实现：

class Solution:
    def editDistance(self , str1: str, str2: str) -> int:
        n1 = len(str1)
        n2 = len(str2)
        #dp[i][j]表示到str1[i]和str2[j]为止的子串需要的编辑距离
        dp = [[0] * (n2 + 1) for i in range(n1 + 1)] 
        #初始化边界
        for i in range(1, n1 + 1): 
            dp[i][0] = dp[i - 1][0] + 1
        for i in range(1, n2 + 1):
            dp[0][i] = dp[0][i - 1] + 1
        #遍历第一个字符串的每个位置
        for i in range(1, n1 + 1): 
            #对应第二个字符串每个位置
            for j in range(1, n2 + 1): 
                #若是字符相同，此处不用编辑
                if str1[i - 1] == str2[j - 1]: 
                    #直接等于二者前一个的距离
                    dp[i][j] = dp[i - 1][j - 1] 
                else:
                    #选取最小的距离加上此处编辑距离1
                    dp[i][j] = min(dp[i - 1][j - 1], min(dp[i - 1][j], dp[i][j - 1])) + 1 
        return dp[n1][n2]

复杂度分析：