[LintCode] Find Missing Positive

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

Example

Given [1,2,0] return 3,
and [3,4,-1,1] return 2.

Challenge 

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

Solution 1. O(n * logn) runtime using sorting.

Algorithm.

1. sort the input array in O(n*logn).

2. find the index of the first positive integer in O(n). If none found or the first positive integer is bigger than 1, return 1. 

3. do a O(n) scan starting from the second positive integer to find the first missing positive.

　Ignore duplicated integers, if found the next consecutive integer, update the next search integer and keep searching.

public class Solution {
    public int firstMissingPositive(int[] A) {
        if(A == null){
            return 1;
        }
        Arrays.sort(A);
        int firstPosIdx = 0;
        for(; firstPosIdx < A.length; firstPosIdx++){
            if(A[firstPosIdx] > 0){
                break;     
            }
        }
        if(firstPosIdx == A.length || A[firstPosIdx] != 1){
            return 1;
        }
        firstPosIdx++;
        int missing = 2;
        for(; firstPosIdx < A.length; firstPosIdx++){
            if(A[firstPosIdx] != A[firstPosIdx - 1] && A[firstPosIdx] != missing){
                break;
            }         
            else if(A[firstPosIdx] == missing){
                missing++;
            }
        }
        return missing;
    }
}

Solution 2.  O(n * logn) runtime, O(n) space using min priority queue.

This solution uses the same idea with solution 1, but implements using min priority queue instead of sorting.

Algorithm.

1. store all positive integers to a min pq.

2.  poll the min integer out of the min pq one by one; If there is a gap in between two consecutively polled 

integers, we found the first missing positive number.

public class Solution {
    public int firstMissingPositive(int[] A) {
        if(A == null || A.length == 0){
            return 1;
        }    
        PriorityQueue<Integer> pos = new PriorityQueue<Integer>();
        for(int i = 0; i < A.length; i++){
            if(A[i] > 0){
                pos.add(A[i]);
            }
        }
        if(pos.size() == 0 || pos.peek() != 1){
            return 1;
        }
        int prev = pos.poll();
        int curr = 0;
        int missing = 2;
        while(pos.size() > 0){
            curr = pos.poll();
            if(curr != prev && curr != missing){
                break;
            }
            else if(curr == missing){
                missing++;
            }
            prev = curr;
        }
        return missing;
    }
}

Solution 3. O(n) runtime, O(n) space, using hash set

public class Solution {
    public int firstMissingPositive(int[] A) {
        if(A == null || A.length == 0){
            return 1;
        } 
        HashSet<Integer> pos = new HashSet<Integer>();
        int minPos = Integer.MAX_VALUE;
        for(int i = 0; i < A.length; i++){
            if(A[i] > 0){
                pos.add(A[i]);
                minPos = Math.min(minPos, A[i]);
            }
        }
        if(pos.size() == 0 || minPos > 1){
            return 1;
        }
        pos.remove(1);
        int missing = 2;
        while(pos.size() > 0){
            if(pos.contains(missing)){
                pos.remove(missing);
                missing++;
            }    
            else{
                break;
            }
        }
        return missing;
    }
}

Solution 4. O(n) runtime, O(1) space.

The runtime of O(n) is already optimal since we need to at least scan the whole input array once to get a correct result.

But can we come up a solution with O(1) extra space usage? 

To solve a problem that involves arrays using O(1) space, the first approach that should come to our mind is using the 

original input array and swap its elements in place, just like in quick sort.

To get the first missing positive integer, we must first check that all the positive integers that are smaller than 

the final answer exist. I.e, these smaller numbers must "appear" before the final answer appears. This relative order 

constraint is similar with sorting but different in that we don't care about the relative orders of all negative numbers.

To enforce the relative ordering of positive numbers, we change the array to have to following property.

For A[i] that exist in the array, if it is positive and <= A.length, then A[i] = i + 1.

This property makes sure that if we have 1s in the array, then A[0] must be 1; if we have 2s in the array,

then A[1] must be 2, etc. 

If A has the above property, then it takes O(n) time to find the first missing positive. We just need to find 

the smallest index i that does not satisfy A[i] == i + 1 and i + 1 is our answer.

The highlighted code changes A to have the above property.  After each swap, the number at index A[i] - 1

meets the property of A[i] = i + 1.

Key ideas:

1. Scan through input array to achieve the following invariant by swapping elements.

A[i] = i + 1;

2. Ignore non-positive integers and integers that are bigger than A.length since these integers won't be the the first missing positive.(If the input array is 1, 2, 3, ....., A.length, then A.length + 1 will be the first missing positive) 

3. For each element A[i], if it meets condition 2, and A[i] != i + 1, swap it with the element at index A[i] - 1,  unless A[A[i] - 1] already equals to A[i]. (This means that at index A[i] - 1, it already satisfies the invariant we're trying to enforce, thus no swap is needed.)

public class Solution {
    public int firstMissingPositive(int[] A) {
        if(A == null || A.length == 0){
            return 1;
        }
 6         for(int i = 0; i < A.length; i++){
 7             while(A[i] > 0 && A[i] <= A.length && A[A[i] - 1] != A[i] && A[i] != (i + 1)){
 8                 int tmp = A[A[i] - 1];
 9                 A[A[i] - 1] = A[i];
10                 A[i] = tmp;
11             }
12         }
        for(int i = 0; i < A.length; i++){
            if(A[i] != i + 1){
                return i + 1;
            }
17         }
18         return A.length + 1;
19     }
20 }

Related Problems

Find the Duplicate Number

Find the Missing Number II

Find the Missing Number