最简单快速符合要求的解法，给个赞吧

正确解1:

class Solution {
public:
    int minNumberdisappered(vector<int>& nums) {
        // 1. 如果数组中都为负数, 结果为 1
        // 2. 如果数组 [1 : N], 结果为 [1 : N + 1], 大过N + 1的数不用考虑
        int n = nums.size();
        // 将负数标记为 n+1
        // [-1,-5,-6,0,1,2,4] -> [8,8,8,8,1,2,4]
        for (int& num: nums) if (num <= 0) num = n + 1;
        // 经过上一步，数组中不再存在负数
        // 将且小于等于n的(即本身是正整数且小于等于n) -1 的位置标记为负数
        // [8,8,8,8,1,2,4] -> [-1,-2,8,-4,1,2,-8]
        for (int i = 0; i < n; ++i) {
            int num = abs(nums[i]);
            if (num <= n) nums[num - 1] = -abs(nums[num - 1]);
        }
        // [-1,-2,8,-4,1,2,-8] return i + 1 ; 即缺失的正整数
        for (int i = 0; i < n; ++i) {
            if (nums[i] > 0) return i + 1;
        }

        return n + 1;
    }
};

正确解2：

class Solution
{
  public:
    /**
     * return the min number
     * @param arr int整型vector the array
     * @return int整型
     */
    int minNumberdisappered(vector<int>& arr)
    {
        // write code here
        for (int a : arr) {
            // 这样做可以让 1 放在 0 的位置， 2 放在 1, 3 放在 2
            while (a > 0 && a <= arr.size() && a != arr[a - 1]) swap(a, arr[a - 1]);
        }
        for (int i = 0; i < arr.size(); ++i) {
            if (arr[i] != i + 1) return i + 1;   // 1 不在 0， 或者 2 不在 1  以此类推 , 不在，则说明没有
        }
        return arr.size() + 1;
    }
};

之前给出来的错误解如下：
由于官方给出的用例都是有序，并且无重复区间值，所以也能过。
最简单快速符合要求的解法

class Solution {
public:
    /**
     * return the min number
     * @param arr int整型vector the array
     * @return int整型
     */
    int minNumberdisappered(vector<int>& arr) {
        // write code here
        int num = 0;
        for (auto a : arr) {
            if (a > 0) num ^= a; // 0 ^ 1 ^ 1 ^ 2 ^ 2 = 0, 0 ^ 1 ^ 2 ^ 2 = 1
        }
        for (int i = 1; i <= arr.size(); ++i) {
            num ^= i; // 如果某个数不存在， num将不为0
        }
        return num == 0? arr.size() + 1 : num;
    }
};