3030<strong >输入:</strong >n = 5, bad = 4
3131<strong >输出:</strong >4
3232<strong >解释:</strong >
33- <code >调用 isBadVersion(3) -> ; false
34- 调用 isBadVersion(5)  ; -> ; true
33+ <code >调用 isBadVersion(3) -> ; false
34+ 调用 isBadVersion(5)  ; -> ; true
3535调用 isBadVersion(4)  ; -> ; true</code >
3636<code >所以,4 是第一个错误的版本。</code >
3737</pre >
@@ -57,33 +57,35 @@ tags:
5757
5858<!-- solution:start -->
5959
60- ### 方法一
60+ ### 方法一:二分查找
61+ 62+ 我们定义二分查找的左边界 $l = 1,ドル右边界 $r = n$。
63+ 64+ 当 $l < r$ 时,我们计算中间位置 $\textit{mid} = \left\lfloor \frac{l + r}{2} \right\rfloor,ドル然后调用 ` isBadVersion(mid) ` 接口,如果返回 $\textit{true},ドル则说明第一个错误的版本在 $[ l, \textit{mid}] $ 之间,我们令 $r = \textit{mid}$;否则第一个错误的版本在 $[ \textit{mid} + 1, r] $ 之间,我们令 $l = \textit{mid} + 1$。
65+ 66+ 最终返回 $l$ 即可。
67+ 68+ 时间复杂度 $O(\log n),ドル空间复杂度 $O(1)$。
6169
6270<!-- tabs:start -->
6371
6472#### Python3
6573
6674``` python
6775# The isBadVersion API is already defined for you.
68- # @param version, an integer
69- # @return an integer
70- # def isBadVersion(version):
76+ # def isBadVersion(version: int) -> bool:
7177
7278
7379class Solution :
74- def firstBadVersion (self n ):
75- """
76- :type n: int
77- :rtype: int
78- """
79- left, right = 1 , n
80- while left < right:
81- mid = (left + right) >> 1
80+ def firstBadVersion (self n : int ) -> int :
81+ l, r = 1 , n
82+ while l < r:
83+ mid = (l + r) >> 1
8284 if isBadVersion(mid):
83- right = mid
85+ r = mid
8486 else :
85- left = mid + 1
86- return left
87+ l = mid + 1
88+ return l
8789```
8890
8991#### Java
@@ -94,16 +96,16 @@ class Solution:
9496
9597public class Solution extends VersionControl {
9698 public int firstBadVersion (int n ) {
97- int left = 1 , right = n;
98- while (left < right ) {
99- int mid = (left + right ) >>> 1 ;
99+ int l = 1 , r = n;
100+ while (l < r ) {
101+ int mid = (l + r ) >>> 1 ;
100102 if (isBadVersion(mid)) {
101- right = mid;
103+ r = mid;
102104 } else {
103- left = mid + 1 ;
105+ l = mid + 1 ;
104106 }
105107 }
106- return left ;
108+ return l ;
107109 }
108110}
109111```
@@ -117,16 +119,16 @@ public class Solution extends VersionControl {
117119class Solution {
118120public:
119121 int firstBadVersion(int n) {
120- int left = 1, right = n;
121- while (left < right ) {
122- int mid = left + ((right - left) >> 1) ;
122+ int l = 1, r = n;
123+ while (l < r ) {
124+ int mid = l + (r - l) / 2 ;
123125 if (isBadVersion(mid)) {
124- right = mid;
126+ r = mid;
125127 } else {
126- left = mid + 1;
128+ l = mid + 1;
127129 }
128130 }
129- return left ;
131+ return l ;
130132 }
131133};
132134```
@@ -143,19 +145,45 @@ public:
143145 */
144146
145147func firstBadVersion(n int) int {
146- left, right := 1, n
147- for left < right {
148- mid := (left + right ) >> 1
148+ l, r := 1, n
149+ for l < r {
150+ mid := (l + r ) >> 1
149151 if isBadVersion(mid) {
150- right = mid
152+ r = mid
151153 } else {
152- left = mid + 1
154+ l = mid + 1
153155 }
154156 }
155- return left
157+ return l
156158}
157159```
158160
161+ #### TypeScript
162+ 163+ ``` ts
164+ /**
165+ * The knows API is defined in the parent class Relation.
166+ * isBadVersion(version: number): boolean {
167+ * ...
168+ * };
169+ */
170+ 171+ var solution = function (isBadVersion : any ) {
172+ return function (n : number ): number {
173+ let [l, r] = [1 , n ];
174+ while (l < r ) {
175+ const = (l + r ) >>> 1 ;
176+ if (isBadVersion (mid )) {
177+ r = mid ;
178+ } else {
179+ l = mid + 1 ;
180+ }
181+ }
182+ return l ;
183+ };
184+ };
185+ ```
186+ 159187#### Rust
160188
161189``` rust
@@ -165,17 +193,16 @@ func firstBadVersion(n int) int {
165193
166194impl Solution {
167195 pub fn first_bad_version (& self , n : i32 ) -> i32 {
168- let mut left = 1 ;
169- let mut right = n ;
170- while left < right {
171- let mid = left + (right - left ) / 2 ;
196+ let (mut l , mut r ) = (1 , n );
197+ while l < r {
198+ let mid = l + (r - l ) / 2 ;
172199 if self . isBadVersion (mid ) {
173- right = mid ;
200+ r = mid ;
174201 } else {
175- left = mid + 1 ;
202+ l = mid + 1 ;
176203 }
177204 }
178- left
205+ l
179206 }
180207}
181208```
@@ -203,17 +230,16 @@ var solution = function (isBadVersion) {
203230 * @return {integer} The first bad version
204231 */
205232 return function (n ) {
206- let left = 1 ;
207- let right = n;
208- while (left < right) {
209- const mid = (left + right) >>> 1 ;
233+ let [l, r] = [1 , n];
234+ while (l < r) {
235+ const mid = (l + r) >>> 1 ;
210236 if (isBadVersion (mid)) {
211- right = mid;
237+ r = mid;
212238 } else {
213- left = mid + 1 ;
239+ l = mid + 1 ;
214240 }
215241 }
216- return left ;
242+ return l ;
217243 };
218244};
219245```
0 commit comments