LeetCode 41. 缺失的第一个正数

41. 缺失的第一个正数

题目：给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。
请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。

链接 https://leetcode.cn/problems/first-missing-positive/

个人思路

1. 找出数组最大的数，然后for循环(1,max+2)，从1开始查看是否在数组中

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        a = max(nums)
        if a <= 0:
            return 1
        for i in range(1,a+2):
            if i not in nums:
                return i

结果超时了。。。

2. 先set集合去重，再排序，然后二分查找？
   先不用二分，思考在目标整数出现之前，数组下标和值之间的关系应该满足：index+1 == value，我们则可以使用for循环，在不满足上面条件时，我们直接返回index+1

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        a = list(set(nums))
        a.sort()
        # 如果1不在数组，那么1就是缺失的第一个整数
        if 1 not in a:
            return 1
        else:
            # 否则截取1及以后的数字
            b = a[a.index(1):]
        # 如果最后一个数字对上了，说明前面不存在缺失数字
        if b[-1] == len(b):
            return b[-1]+1
        else:
            for i,j in enumerate(b):
                if i+1 != j:
                    return i+1

时间结果还行，但内存占用较多

二分法：

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        a = list(set(nums))
        a.sort()
        if 1 not in a:
            return 1
        else:
            # 截取1以后的数字
            b = a[a.index(1):]
        if b[-1] == len(b):
            return b[-1]+1
        # 此时排序的数组中必有漏掉的整数，二分找出该整数
        else:
            left = 0
            right = len(b)
            mid = 0
            # 边界比较难处理，干脆另外处理
            while left < right and right - left > 3:
                mid = int((left + right) / 2)
                # 此时，缺失数字在右边，左指针偏移
                if b[mid] == mid + 1:
                    left = mid
                # 此时，缺失数字在左边，右指针偏移
                else:
                    right = mid
        # 排除当缺失数字刚好在right时，访问不到的情况，所以右边最好加1
        # 因为缺失数字不可能在最后面，所以不需要判断是否超过界限
        for i in range(min(left,mid,right),max(left,mid,right)+1):
            if b[i] != i+1:
                return i+1

时间确实快了不少

3. 前面的都没有考虑内存问题：
   遍历一次数组把大于等于1的和小于数组大小的值放到原数组对应位置，然后再遍历一次数组查当前下标是否和值对应，如果不对应那这个下标就是答案，否则遍历完都没出现那么答案就是数组长度加1。

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        n = len(nums)
        for i in range(n):
            while 1 <= nums[i] <= n and nums[nums[i]-1] != nums[i]:
                temp = nums[i] 
                nums[i],nums[temp-1]  = nums[temp-1] ,nums[i]
        for i in range(n):
            if i+1 != nums[i]:
                return i+1
        return n+1

这里注意while里面不能使用nums[i],nums[nums[i]-1] = nums[nums[i]-1] ,nums[i]，因为在交换完nums[i] = nums[nums[i]-1]这个后，nums[nums[i]-1] = nums[i]中左边nums[i]会使用前面交换后新的nums[i]，要改为temp = nums[i] ; nums[i],nums[temp-1] = nums[temp-1] ,nums[i]

也可以这样写：
注意到上面的方法可能会陷入死循环。如果 nums[i] 恰好与nums[x−1] 相等，那么就会无限交换下去。此时我们有 nums[i]=x=nums[x−1]，说明 x 已经出现在了正确的位置。因此我们可以跳出循环，开始遍历下一个数。

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        n = len(nums)
        for i in range(n):
            while 1 <= nums[i] <= n and nums[nums[i] - 1] != nums[i]:
                nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i] - 1]
        for i in range(n):
            if nums[i] != i + 1:
                return i + 1
        return n + 1

复杂度分析：
时间复杂度：O(N)，其中 N 是数组的长度。
空间复杂度：O(1)。

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/first-missing-positive/solution/que-shi-de-di-yi-ge-zheng-shu-by-leetcode-solution/