19.2.4 [LeetCode 41] First Missing Positive

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

Example 1:

Input: [1,2,0]
Output: 3

Example 2:

Input: [3,4,-1,1]
Output: 2

Example 3:

Input: [7,8,9,11,12]
Output: 1

Note:

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

题意

找到数组中最小的没出现的正整数

题解

一开始用空间换时间还是慢

还发现限制了空间，肯定没法用这种方法

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        vector<bool>visited(nums.size()+2,false);
        int size = nums.size();
        for (int i = 0; i < size; i++) {
            if (nums[i] <= size&&nums[i]>=1)
                visited[nums[i]] = true;
        }
        for (int i = 1; i < size + 2; i++)
            if (!visited[i])return i;
        return -1;
    }
};

稍微改了一下，用原数组来存储，思路是按顺序在数组从下标0开始排1，2，3...不过没有变快就是了

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        int size = nums.size(), p = 0;
        while (p < size) {
            if (nums[p] == p + 1) {
                p++;
                continue;
            }
            int tmp = nums[p];
            if (tmp <= size && tmp > p && tmp != nums[tmp-1]) {
                nums[p] = nums[tmp - 1];
                nums[tmp - 1] = tmp;
            }
            else {
                nums[p] = nums[size - 1];
                size--;
            }
        }
        return p + 1;
    }
};

 惊了，改用了swap函数就变快了，不知swap咋写的

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        int size = nums.size(), p = 0;
        while (p < size) {
            if (nums[p] == p + 1) {
                p++;
                continue;
            }
            int tmp = nums[p];
            if (tmp <= size && tmp > p && tmp != nums[tmp - 1])
                swap(nums[p], nums[nums[p] - 1]);
            else {
                nums[p] = nums[size - 1];
                size--;
            }
        }
        return p + 1;
    }
};