25
25
26
26
## 解法
27
27
28
- 二分法。
28
+ ** 方法一:二分查找**
29
+
30
+ 我们可以使用二分查找的方法找到这个缺失的数字。初始化左边界 $l=0$,右边界 $r=n$,其中 $n$ 是数组的长度。
31
+
32
+ 每次计算中间元素的下标 $mid$,如果 $nums[ mid] \gt mid$,则缺失的数字一定在区间 $[ l,..mid] $ 中,否则缺失的数字一定在区间 $[ mid+1,..r] $ 中。
33
+
34
+ 最后返回左边界 $l$ 即可。
35
+
36
+ 时间复杂度 $O(\log n)$,空间复杂度 $O(1)$。其中 $n$ 是数组的长度。
29
37
30
38
<!-- tabs:start -->
31
39
34
42
``` python
35
43
class Solution :
36
44
def missingNumber (self , nums : List[int ]) -> int :
37
- l, r = 0 , len (nums) - 1
38
- if r == 0 or nums[0 ] == 1 :
39
- return nums[0 ] ^ 1
40
- if nums[r] == r:
41
- return r + 1
42
- while r - l > 1 :
43
- m = (l + r) >> 1
44
- if nums[m] == m:
45
- l = m
45
+ l, r = 0 , len (nums)
46
+ while l < r:
47
+ mid = (l + r) >> 1
48
+ if nums[mid] > mid:
49
+ r = mid
46
50
else :
47
- r = m
48
- return nums[r] - 1
51
+ l = mid + 1
52
+ return l
49
53
```
50
54
51
55
### ** Java**
52
56
53
57
``` java
54
58
class Solution {
55
59
public int missingNumber (int [] nums ) {
56
- int l = 0 , r = nums. length - 1 ;
57
- if (r == 0 || nums[0 ] == 1 ) {
58
- return nums[0 ] ^ 1 ;
59
- }
60
- if (nums[r] == r) {
61
- return r + 1 ;
60
+ int l = 0 , r = nums. length;
61
+ while (l < r) {
62
+ int mid = (l + r) >>> 1 ;
63
+ if (nums[mid] > mid) {
64
+ r = mid;
65
+ } else {
66
+ l = mid + 1 ;
67
+ }
62
68
}
63
- while (r - l > 1 ) {
64
- int m = (l + r) >>> 1 ;
65
- if (nums[m] == m) {
66
- l = m;
69
+ return l;
70
+ }
71
+ }
72
+ ```
73
+
74
+ ### ** C++**
75
+
76
+ ``` cpp
77
+ class Solution {
78
+ public:
79
+ int missingNumber(vector<int >& nums) {
80
+ int l = 0, r = nums.size();
81
+ while (l < r) {
82
+ int mid = (l + r) >> 1;
83
+ if (nums[ mid] > mid) {
84
+ r = mid;
67
85
} else {
68
- r = m ;
86
+ l = mid + 1 ;
69
87
}
70
88
}
71
- return nums[r] - 1 ;
89
+ return l ;
72
90
}
91
+ };
92
+ ```
93
+
94
+ ### **Go**
95
+
96
+ ```go
97
+ func missingNumber(nums []int) int {
98
+ l, r := 0, len(nums)
99
+ for l < r {
100
+ mid := (l + r) >> 1
101
+ if nums[mid] > mid {
102
+ r = mid
103
+ } else {
104
+ l = mid + 1
105
+ }
106
+ }
107
+ return l
73
108
}
74
109
```
75
110
@@ -81,43 +116,39 @@ class Solution {
81
116
* @return {number}
82
117
*/
83
118
var missingNumber = function (nums ) {
84
- if (! nums || ! nums .length ) return 0 ;
85
- let left = 0 ;
86
- let right = nums .length - 1 ;
87
- while (left < right) {
88
- let mid = left + ~~ ((right - left) / 2 );
89
- if (nums[mid] !== mid) {
90
- right = mid;
119
+ let l = 0 ;
120
+ let r = nums .length ;
121
+ while (l < r) {
122
+ const mid = (l + r) >> 1 ;
123
+ if (nums[mid] > mid) {
124
+ r = mid;
91
125
} else {
92
- left = mid + 1 ;
126
+ l = mid + 1 ;
93
127
}
94
128
}
95
- return nums[left] === left ? nums . length : left ;
129
+ return l ;
96
130
};
97
131
```
98
132
99
- ### ** C++ **
133
+ ### ** Rust **
100
134
101
- ``` cpp
102
- class Solution {
103
- public:
104
- int missingNumber(vector<int >& nums) {
105
- int left = 0, right = nums.size();
106
- while (left < right) {
107
- int mid = left + (right - left) / 2;
108
- if (nums[ mid] == mid) {
109
- left = mid + 1;
135
+ ``` rust
136
+ impl Solution {
137
+ pub fn missing_number (nums : Vec <i32 >) -> i32 {
138
+ let (mut l , mut r ) = (0 , nums . len () as i32 );
139
+ while l < r {
140
+ let mut mid = (l + r ) >> 1 ;
141
+ if nums [mid as usize ] > mid {
142
+ r = mid ;
110
143
} else {
111
- right = mid;
144
+ l = mid + 1 ;
112
145
}
113
146
}
114
- return left;
147
+ l
115
148
}
116
- };
149
+ }
117
150
```
118
151
119
- ### **Rust**
120
-
121
152
``` rust
122
153
impl Solution {
123
154
pub fn missing_number (nums : Vec <i32 >) -> i32 {
@@ -131,42 +162,21 @@ impl Solution {
131
162
}
132
163
```
133
164
134
- ``` rust
135
- impl Solution {
136
- pub fn missing_number (nums : Vec <i32 >) -> i32 {
137
- let mut prev = 0 ;
138
- for & num in nums . iter () {
139
- if prev != num {
140
- return prev ;
141
- }
142
- prev += 1 ;
143
- }
144
- prev
145
- }
146
- }
147
- ```
148
-
149
165
### ** C#**
150
166
151
167
``` cs
152
168
public class Solution {
153
169
public int MissingNumber (int [] nums ) {
154
- int l = 0 , r = nums .Length - 1 ;
155
- if (r == 0 || nums [0 ] == 1 ) {
156
- return nums [0 ] ^ 1 ;
157
- }
158
- if (nums [r ] == r ) {
159
- return r + 1 ;
160
- }
170
+ int l = 0 , r = nums .Length ;
161
171
while (l < r ) {
162
172
int mid = (l + r ) >> 1 ;
163
- if (nums [mid ] == mid ) {
164
- l = mid + 1 ;
165
- } else {
173
+ if (nums [mid ] > mid ) {
166
174
r = mid ;
175
+ } else {
176
+ l = mid + 1 ;
167
177
}
168
178
}
169
- return r ;
179
+ return l ;
170
180
}
171
181
}
172
182
```
0 commit comments