# 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.

## SOLUTION 1:

http://m.blog.csdn.net/blog/hellobinfeng/17348055

http://n00tc0d3r.blogspot.com/2013/03/find-first-missing-positive.html

http://www.cnblogs.com/AnnieKim/archive/2013/04/21/3034631.html

A few quick thoughts:

• Sort all numbers and iterate through to find the first missing integer? No, most sorting algorithms take time at least O(nlogn).
• How about linear sorting algorithm? No, bucket sort requires O(n) space.
• Mapping all positive integers to a hash table and iterate from 1 to the length of the array to find out the first missing one? No, hash table requires O(n) space.

Then, how to solve this?

Let's take another look at the problem. It is asking for the first missing POSITIVE integer.
So, given a number in the array,

• if it is non-positive, ignore it;
• if it is positive, say we have A[i] = x, we know it should be in slot A[x-1]! That is to say, we can swap A[x-1] with A[i] so as to place x into the right place.
We need to keep swapping until all numbers are either non-positive or in the right places. The result array could be something like [1, 2, 3, 0, 5, 6, ...]. Then it's easy to tell that the first missing one is 4 by iterate through the array and compare each value with their index.

 1 public int firstMissingPositive1(int[] A) {
2         // bug 3: when length is 0, return 1;
3         if (A == null) {
4             return 0;
5         }
6
7         for (int i = 0; i < A.length; i++) {
8             // BUG 1: TLE , should judge when A[i] - 1 == i;
9             while (A[i] - 1 != i && A[i] > 0) {
10                 // bug 2: cant exchange a same node: A[A[i] - 1] != A[i]
11                 if (A[i] - 1 < A.length && A[A[i] - 1] != A[i]) {
12                     swap(A, i, A[i] - 1);
13                 } else {
14                     // when the number is out of range, delete it.
15                     A[i] = 0;
16                 }
17             }
18         }
19
20         for (int i = 0; i < A.length; i++) {
21             if (A[i] <= 0) {
22                 return i + 1;
23             }
24         }
25
26         return A.length + 1;
27     }
28
29     public void swap(int[] A, int l, int r) {
30         int tmp = A[l];
31         A[l] = A[r];
32         A[r] = tmp;
33     }
View Code

1: A[i] is in the range;
2: A[i] > 0.
3: The target is different; （如果不判断这个，会造成死循环，因为你交换过来一个一样的值）

 1 // SOLUTION 2:
2     public int firstMissingPositive(int[] A) {
3         // bug 3: when length is 0, return 1;
4         if (A == null) {
5             return 0;
6         }
7
8         for (int i = 0; i < A.length; i++) {
9             // 1: A[i] is in the range;
10             // 2: A[i] > 0.
11             // 3: The target is different;
12             while (A[i] <= A.length && A[i] > 0 && A[A[i] - 1] != A[i]) {
13                 swap(A, i, A[i] - 1);
14             }
15         }
16
17         for (int i = 0; i < A.length; i++) {
18             if (A[i] != i + 1) {
19                 return i + 1;
20             }
21         }
22
23         return A.length + 1;
24     }
View Code

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/array/FirstMissingPositive.java

posted on 2015-01-03 22:45  Yu's Garden  阅读(...)  评论(...编辑  收藏

• 随笔 - 166
• 文章 - 1
• 评论 - 71
• 引用 - 0