LeetCode: First Missing Positive 解題報告

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：

 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

簡化後，解2：

其實交換的條件就是3個：

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