寻找不在数组中最小的正整数 First Missing Positive

问题：给出一个无序的数组，其中包含有任意的整数。现在要求返回不包含在数组中的最小的正整数。

要求：时间复杂度O(n)，空间复杂度O(1)。

思路：如果不要求空间复杂度，可以用hash、map进行统计。但是现在，不允许借助临时空间。但是对于无序数组，不借助空间怎么可能统计的出来。

方法一：把输入数组自己作为临时空间使用。

这一方法用了一个类似计数排序的技巧。把数组下标看作一个数的hash值，把一个正数是否存在这一信息存储在该正数值对应的下标位置里。但是不能够覆盖掉数组本身的数据，所以利用负号这一标志来代表该位置所对应下标数值的存在性。利用这个方法，就能够做到把数组本身作为自己的hash表。

在这么做之前，要先数组中没有用的负数移到数组最左边去。

class Solution {
public:
    int firstMissingPositive(int A[], int n) {
        if(n == 0)
            return 1;
        int k = seperate(A, n); //A[0..k]
        if(k == -1)
            return 1;
        
        //mark the index
        for(int i=0;i<=k;i++)
        {
            int value = abs(A[i]);
            if(value > k+1)
                continue;
            A[value-1] = - abs(A[value-1]); //防止重复取反导致记录错误
        }
        
        for(int i=0;i<=k;i++)
        {
            if(A[i] > 0)
                return i+1;
        }
        return k+2;
    }
    
    int seperate(int A[], int n) //返回正数序列的末尾坐标
    {
        int left = 0, right = n-1;
        while(left < right)
        {
            while(left < right && A[left] > 0)
                left++;
            while(left < right && A[right] <=0)
                right--;
            
            if(left < right)
                swap(A[left], A[right]);
        }
        if(A[left] > 0)
            return left;
        else
            return left-1;
    }
    
    void swap(int &a, int &b)
    {
        a = a^b;
        b = a^b;
        a = a^b;
    }
};

方法二：利用桶排序的思想。将正整数放在对应的下标位置上。1放在A[0]，2放在A[1]……由于不能用辅助空间，所以需要交换来完成放置。对于一个元素数值A[i]，如果0<A[i]<n，那么它的最终位置应该是A[A[i]-1]，因此交换A[i],A[A[i]-1]即可；如果不是正整数或是超过数组下标范围，那么就没有可放置的最终位置（这个数也必然不会是最终要找的数）。

class Solution {
public:
    int firstMissingPositive(int A[], int n) {
        bucket(A, n);
        
        for(int i=0;i<n;i++)
            if(A[i] != i+1)
                return i+1;
        return n+1;
    }
    
    void bucket(int A[], int n)
    {
        for(int i=0;i<n;i++)
            while(A[i] != i+1)
            {
                if(A[i] <= 0 || A[i] > n || A[i] == A[A[i]-1])
                    break;
                swap(A[i], A[A[i]-1]);
            }
    }
};