LeetCode- First Missing Positive

算法分析与设计，第14周博客

41. First Missing Positive

Given an unsorted integer array, find the first missing positive integer.

For example,
Given [1,2,0] return 3,
and [3,4,-1,1] return 2.

Your algorithm should run in O(n) time and uses constant space.

题目的意思很简单，给出一组整数，要求其中第一个没有出现的正整数，并且要求算法的时间复杂度是O(n)，并且空间复杂度是O(1)。

如果没有其他限制，能够想到的第一个方法就是取一个数组in，大小为n+1，然后对原数组进行遍历，如果遇到一个在(0,n]之间的整数就将in中相应的下标标识为true，然后只需要对in数组进行遍历，查看哪个下标是false，就可以了。所实现的代码如下，但是这个方法所用的空间是O(n)而不是O(1)，所以是不符合题目要求的：

    int firstMissingPositive(vector<int>& nums) {
        int n = nums.size();
        vector<bool> in(n+1, false);
        for (int i = 0; i < n; ++i) {
            if (nums[i] > 0 && nums[i] <= n) {
                in[nums[i]] = true;
            }
        }
        for (int i = 1; i <= n; ++i) {
            if (!in[i])
                return i;
        }
        return n+1;
    }

那么如何能够将空间复杂度从O(n) 降低到O(1)呢？我们使用了另外一个数组来表示某个数有无存在于原来的数组，那么，如果我们不额外的使用这个数组，那么又如何能够存储这个信息呢？

答案就是使用原数组本身。将相应的正整数放在其相应的下标中，不就正好解决这个问题了。所实现的代码如下：

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        for (int i = 0; i < nums.size(); ) {
            int cur = nums.at(i);
            if (cur > 0 && cur <= nums.size() && nums.at(cur-1) != cur) {
                swap(nums, i, cur - 1);
            }
            else {
                ++i;
            }
        }
        for (int i = 0; i < nums.size(); ++i) {
            if (i + 1 != nums.at(i))
                return i + 1;
        }
        return nums.size() + 1;
    }
    void swap(vector<int>& nums, int i, int j) {
        int tmp = nums.at(i);
        nums.at(i) = nums.at(j);
        nums.at(j) = tmp;
    }
};

数组其实是有两个信息的，一个是所存储的数，另一个便是数组的下标，这一点或许可以帮助我们改进算法的空间复杂度。