4545
4646<!-- 这里可写通用的实现逻辑 -->
4747
48- 从简单到复杂。
48+ ** 方法一：原地交换 **
4949
50- ** 哈希表： **
50+ 我们假设数组 ` nums ` 长度为 $n$，那么最小的正整数一定在 $ [ 1, .., n + 1 ] $ 之间。我们可以遍历数组，将数组中的每个数 $x$ 交换到它应该在的位置上，即 $x$ 应该在的位置为 $x - 1$。如果 $x$ 不在 $ [ 1, n + 1 ] $ 之间，那么我们就不用管它。
5151
52- 无视空间需求，使用哈希表或数组来记录 ` nums ` 中所有出现过的 ** 正整数 ** 。然后在其中查找 ` (1 ~ nums.length) ` ，返回第一个不存在记录的正整数即可 。
52+ 遍历结束后，我们再遍历数组，如果 $i+1$ 不等于 $ nums[ i ] $，那么 $i+1$ 就是我们要找的最小的正整数 。
5353
54- ** 排序：**
55-
56- 方法之一
57-
58- ``` txt
59- FRRST-MISSING-POSITIVE(A)
60- A.sort()
61- r = 1
62- for n in A
63- if n == r
64- r++
65- else if n > r
66- break
67- return r
68- ```
69-
70- ** 常数空间：**
71-
72- 有一个现成的记录容器，那就是 ` nums ` 本身。
73-
74- 使用下标来记录数据，只关注正整数，对于正整数 ` x ` ，将其归为至 ` nums[x - 1] ` 位置（与对应位置的元素进行交换）。
75-
76- 当所有的正整数归位之后，再次遍历 ` nums ` ，找到第一个不满足 ` nums[i] != i + 1 ` 表达式的位置，返回 ` i + 1 ` 。若是全部满足，则返回 ` nums.length + 1 ` 。
77-
78- > 因为存在重复元素，只要 ` nums[x - 1] == x ` 条件已满足，那么再遇到 ` x ` 时，直接跳过。
54+ 时间复杂度 $O(n)$，空间复杂度 $O(1)$。
7955
8056<!-- tabs:start -->
8157
@@ -85,45 +61,45 @@ FRRST-MISSING-POSITIVE(A)
8561
8662``` python
8763class Solution :
88- def firstMissingPositive (self nums ):
89- """
90- :type nums: List[int]
91- :rtype: int
92- """
93-
94- i = 1
95- while i in nums:
96- i += 1
97- return i
64+ def firstMissingPositive (self nums : List[int ]) -> int :
65+ def swap (i , j ):
66+ nums[i], nums[j] = nums[j], nums[i]
67+
68+ n = len (nums)
69+ for i in range (n):
70+ while 1 <= nums[i] <= n and nums[i] != nums[nums[i] - 1 ]:
71+ swap(i, nums[i] - 1 )
72+ for i in range (n):
73+ if i + 1 != nums[i]:
74+ return i + 1
75+ return n + 1
9876```
9977
10078### ** Java**
10179
10280<!-- 这里可写当前语言的特殊实现逻辑 -->
10381
10482``` java
105- public class Solution {
106- public int firstMissingPositive (int [] num ) {
107- for ( int i = 0 ; i < num . length; i ++ ) {
108- if (num[i] > 0 && num[i] < num . length && num[num[i] - 1 ] != num[i] ) {
109- swap(num, i, num [i] - 1 );
110- i -- ;
83+ class Solution {
84+ public int firstMissingPositive (int [] nums ) {
85+ int n = nums . length;
86+ for ( int i = 0 ; i < n; ++ i ) {
87+ while (nums[i] >= 1 && nums[i] <= n && nums [i] != nums[nums[i] - 1 ]) {
88+ swap(nums, i, nums[i] - 1 ) ;
11189 }
11290 }
113-
114- for (int i = 0 ; i < num. length; i++ ) {
115- if (i + 1 != num[i]) {
91+ for (int i = 0 ; i < n; ++ i) {
92+ if (i + 1 != nums[i]) {
11693 return i + 1 ;
11794 }
11895 }
119-
120- return num. length + 1 ;
96+ return n + 1 ;
12197 }
12298
123- private void swap (int [] num , int i , int j ) {
124- int temp = num [i];
125- num [i] = num [j];
126- num [j] = temp ;
99+ private void swap (int [] nums , int i , int j ) {
100+ int t = nums [i];
101+ nums [i] = nums [j];
102+ nums [j] = t ;
127103 }
128104}
129105```
@@ -134,25 +110,41 @@ public class Solution {
134110class Solution {
135111public:
136112 int firstMissingPositive(vector<int >& nums) {
137- sort(nums.begin(), nums.end());
138- int len = nums.size();
139- if (len == 0) return 1;
140- int i = 0;
141- while (nums[ i] <= 0 && i < len) i++;
142- if (i == len) return 1;
143-
144- int tmp = 1;
145- while (i < len) {
146- if (nums[i] != tmp) return tmp;
147- while (len > i + 1 && nums[i] == nums[i + 1]) i++; //去重
148- i++;
149- tmp++;
113+ int n = nums.size();
114+ for (int i = 0; i < n; ++i) {
115+ while (nums[ i] >= 1 && nums[ i] <= n && nums[ i] != nums[ nums[ i] - 1] ) {
116+ swap(nums[ i] , nums[ nums[ i] - 1] );
117+ }
118+ }
119+ for (int i = 0; i < n; ++i) {
120+ if (i + 1 != nums[ i] ) {
121+ return i + 1;
122+ }
150123 }
151- return tmp ;
124+ return n + 1 ;
152125 }
153126};
154127```
155128
129+ ### **Go**
130+
131+ ```go
132+ func firstMissingPositive(nums []int) int {
133+ n := len(nums)
134+ for i := range nums {
135+ for nums[i] >= 1 && nums[i] <= n && nums[i] != nums[nums[i]-1] {
136+ nums[i], nums[nums[i]-1] = nums[nums[i]-1], nums[i]
137+ }
138+ }
139+ for i, v := range nums {
140+ if i+1 != v {
141+ return i + 1
142+ }
143+ }
144+ return n + 1
145+ }
146+ ```
147+
156148### ** C**
157149
158150``` c
0 commit comments