lintcode 中等题：First Missing Positive 丢失的第一个正整数

题目

丢失的第一个正整数

给出一个无序的整数数组，找出其中没有出现的最小正整数。

样例

如果给出 [1,2,0], return 3 如果给出 [3,4,-1,1], return 2

挑战

只允许时间复杂度O(n)的算法，并且只能使用常数级别的空间。

解题 

感觉好像好像很复杂，通过率21%也是比较低的了。

找了一个很不好的方法

步骤：

1.先找出数组中正整数的最小值，Min

2.若Min>1 显然最小的不在数组中的正整数就是1

3.这里的都是最小值Min == 1的情况

对于这个情况，只需要判断  对最小的i， Min + i 是否在数组中的正整数部分，这里需要定义一个ArrayList存放正整数部分的数，方便判断Min+i是否在ArrayList中。最小的i对于的Min+i就是答案。

这里时间复杂度和空间复杂度都是O(N)

public class Solution {
    /**
     * @param A: an array of integers
     * @return: an integer
     */
    public int firstMissingPositive(int[] A) {
        // write your code here
        if(A.length ==0)
            return 1;
        // if(A.length ==1){
        //     if(A[0]<= 0)
        //         return 1;
        //     return A[0]+1;
        // }
        // 1.找到正数的最小值
        // 2.最小值>1 return 1
        // 3.最小值<0 return 1
        // 4.最小值是1，最小值向上加 1 不存在的话就是答案
        int Min = Integer.MAX_VALUE;
        int MinInt = Integer.MAX_VALUE;
        ArrayList<Integer> list = new ArrayList<Integer>();
        for(int i=0;i< A.length;i++){
            if(A[i]>0){
                list.add(A[i]);
                if(A[i] < Min)
                    Min = A[i];
            }
        }
        if(Min>1 )
            return 1;
        int i = 1;
        // 最小值等于 1
        while(i<= A.length){
            if(!list.contains(Min + i)){
                MinInt = Min + i;
                break;
            }
            i = i + 1;
        }
        return MinInt;
    }
}

Java Code

总耗时: 2210 ms

这个和寻找缺失的数好像很像，虽然改写后的程序，理解不透，但是LeetCode的测试样例，造成无法通过

样例：[1,1]这样会陷入死循环。

程序如下

public class Solution {
    /**
     * @param A: an array of integers
     * @return: an integer
     */
    public int firstMissingPositive(int[] A) {
        // write your code here
        if(A.length == 0)
            return 1;
        int n = A.length;
        for(int i =0 ;i< n ;i++){
            while(A[i] != i + 1){
                if(A[i] <= 0 || A[i] > n)
                    break;
                int tmp = A[i];
                A[i] = A[tmp - 1];
                A[tmp - 1] = tmp;
            }
        }
        for(int i =0;i< n ;i++)
            if( A[i] != i+ 1)
                return i+1;
        return n + 1;
    }
}

Java Code

class Solution:
    # @param A, a list of integers
    # @return an integer
    def firstMissingPositive(self, A):
        # write your code here
        if A == None:
            return 1
        n = len(A)
        nums = A[:]
        for i in range(n):
            while A[i] != i+1:
                nums = A[:]
                if A[i]<=0 or A[i]>=n:
                    break
                tmp = A[i]
                A[i] = A[tmp-1]
                A[tmp-1] = tmp
                # print ‘before:‘,nums
                # print ‘later:‘,A
        for i in range(n):
            if A[i]!= i +1:
                return i+1
        return n +1
                

Python Code