【Leetcode】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.

【分析】

重点是unsorted, 然后是运算复杂度是O(n),所以就不能用Arrays,sort, 因为O(nlgn);

虽然不能再另外开辟非常数级的额外空间，但是可以在输入数组上就地进行swap操作。

思路：交换数组元素，使得数组中第i位存放数值(i+1)。最后遍历数组，寻找第一个不符合此要求的元素，返回其下标。整个过程需要遍历两次数组，复杂度为O(n)。

下图以题目中给出的第二个例子为例，讲解操作过程。

n个元素的数组，里面的数都是0~n-1范围内的，求数组中重复的某一个元素，没有返回-1, 要求时间性能O(n) 空间性能O(1)

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

	      public int firstMissingPositive(int[] A) {
	          int i = 0;
	          while(i < A.length){
	              if(A[i] == i+1 || A[i] <= 0 || A[i] > A.length) i++;
	              else if(A[A[i]-1] != A[i]) swap(A, i, A[i]-1);
	              else i++;
	          }
	          i = 0;
	          while(i < A.length && A[i] == i+1) i++;
	          return i+1;
	      }

	      private void swap(int[] A, int i, int j){
	          int temp = A[i];
	          A[i] = A[j];
	          A[j] = temp;
	      }

hashSet:

public int firstMissingPositive(int[] nums) {
    if(nums.length==0) return 1;
    HashSet<Integer> s = new HashSet<Integer>();
    for(int a: nums){
        s.add(a);
    }
    int num=0;
    for(int i=1;i<=nums.length;i++){
        if(!s.contains(i)){ 
        return i;
        }
        num = i;
    }

 return num+1;   
}