@@ -52,16 +52,16 @@ tags:
5252
5353### 方法一:二分查找
5454
55- 我们定义二分查找的左边界 $left =0,ドル右边界 $right =n-1$。
55+ 我们定义二分查找的左边界 $l =0,ドル右边界 $r =n-1$。
5656
57- 每一次循环,我们计算中间位置 $mid=(left+right )/2,ドル然后判断 $ nums[ mid] $ 和 $target$ 的大小关系:
57+ 每一次循环,我们计算中间位置 $\text{ mid}=(l+r )/2,ドル然后比较 $\text{ nums} [ \text{ mid} ] $ 和 $\text{ target}$ 的大小。
5858
59- - 如果 $nums[ mid] \geq target,ドル则说明 $ target$ 在 $ [ left, mid ] $ 之间,我们将 $right$ 更新为 $ mid$;
60- - 否则,说明 $target$ 在 $ [ mid+1, right ] $ 之间,我们将 $left$ 更新为 $ mid+1$。
59+ - 如果 $\text{ nums} [ \text{ mid} ] \geq \text{ target},ドル说明 $\text{ target}$ 在左半部分,我们将右边界 $r$ 移动到 $\text{ mid} $;
60+ - 否则,说明 $\text{ target}$ 在右半部分,我们将左边界 $l$ 移动到 $\text{ mid} +1$。
6161
62- 当 $left \geq right$ 时,我们判断 $ nums[ left ] $ 是否等于 $ target,ドル如果等于则返回 $left ,ドル否则返回 $-1$。
62+ 循环结束的条件是 $l<r,ドル此时 $\text{ nums} [ l ] $ 就是我们要找的目标值,如果 $\text{nums} [ l ] =\text{ target},ドル返回 $l ,ドル否则返回 $-1$。
6363
64- 时间复杂度 $O(\log n),ドル其中 $n$ 是数组 $nums$ 的长度。空间复杂度 $O(1)$。
64+ 时间复杂度 $O(\log n),ドル其中 $n$ 是数组 $\text{ nums} $ 的长度。空间复杂度 $O(1)$。
6565
6666<!-- tabs:start -->
6767
@@ -70,31 +70,31 @@ tags:
7070``` python
7171class Solution :
7272 def search (self nums : List[int ], target : int ) -> int :
73- left, right = 0 , len (nums) - 1
74- while left < right :
75- mid = (left + right ) >> 1
73+ l, r = 0 , len (nums) - 1
74+ while l < r :
75+ mid = (l + r ) >> 1
7676 if nums[mid] >= target:
77- right = mid
77+ r = mid
7878 else :
79- left = mid + 1
80- return left if nums[left ] == target else - 1
79+ l = mid + 1
80+ return l if nums[l ] == target else - 1
8181```
8282
8383#### Java
8484
8585``` java
8686class Solution {
8787 public int search (int [] nums , int target ) {
88- int left = 0 , right = nums. length - 1 ;
89- while (left < right ) {
90- int mid = (left + right ) >> 1 ;
88+ int l = 0 , r = nums. length - 1 ;
89+ while (l < r ) {
90+ int mid = (l + r ) >> 1 ;
9191 if (nums[mid] >= target) {
92- right = mid;
92+ r = mid;
9393 } else {
94- left = mid + 1 ;
94+ l = mid + 1 ;
9595 }
9696 }
97- return nums[left ] == target ? left : - 1 ;
97+ return nums[l ] == target ? l : - 1 ;
9898 }
9999}
100100```
@@ -105,15 +105,16 @@ class Solution {
105105class Solution {
106106public:
107107 int search(vector<int >& nums, int target) {
108- int left = 0, right = nums.size() - 1;
109- while (left < right) {
110- int mid = left + right >> 1;
111- if (nums[ mid] >= target)
112- right = mid;
113- else
114- left = mid + 1;
108+ int l = 0, r = nums.size() - 1;
109+ while (l < r) {
110+ int mid = (l + r) >> 1;
111+ if (nums[ mid] >= target) {
112+ r = mid;
113+ } else {
114+ l = mid + 1;
115+ }
115116 }
116- return nums[ left ] == target ? left : -1;
117+ return nums[ l ] == target ? l : -1;
117118 }
118119};
119120```
@@ -122,46 +123,59 @@ public:
122123
123124```go
124125func search(nums []int, target int) int {
125- left, right := 0, len(nums)-1
126- for left < right {
127- mid := (left + right ) >> 1
126+ l, r := 0, len(nums)-1
127+ for l < r {
128+ mid := (l + r ) >> 1
128129 if nums[mid] >= target {
129- right = mid
130+ r = mid
130131 } else {
131- left = mid + 1
132+ l = mid + 1
132133 }
133134 }
134- if nums[left ] == target {
135- return left
135+ if nums[l ] == target {
136+ return l
136137 }
137138 return -1
138139}
139140```
140141
142+ #### TypeScript
143+ 144+ ``` ts
145+ function search(nums : number [], target : number ): number {
146+ let [l, r] = [0 , nums .length - 1 ];
147+ while (l < r ) {
148+ const = (l + r ) >> 1 ;
149+ if (nums [mid ] >= target ) {
150+ r = mid ;
151+ } else {
152+ l = mid + 1 ;
153+ }
154+ }
155+ return nums [l ] === target ? l : - 1 ;
156+ }
157+ ```
158+ 141159#### Rust
142160
143161``` rust
144- use std :: cmp :: Ordering ;
145- 146162impl Solution {
147163 pub fn search (nums : Vec <i32 >, target : i32 ) -> i32 {
148- let mut l = 0 ;
149- let mut r = nums . len ();
164+ let mut l : usize = 0 ;
165+ let mut r : usize = nums . len ()- 1 ;
150166 while l < r {
151167 let mid = (l + r ) >> 1 ;
152- match nums [mid ]. cmp (& target ) {
153- Ordering :: Less => {
154- l = mid + 1 ;
155- }
156- Ordering :: Greater => {
157- r = mid ;
158- }
159- Ordering :: Equal => {
160- return mid as i32 ;
161- }
168+ if nums [mid ] >= target {
169+ r = mid ;
170+ } else {
171+ l = mid + 1 ;
162172 }
163173 }
164- - 1
174+ if nums [l ] == target {
175+ l as i32
176+ } else {
177+ - 1
178+ }
165179 }
166180}
167181```
@@ -175,17 +189,16 @@ impl Solution {
175189 * @return {number}
176190 */
177191var search = function (nums , target ) {
178- let left = 0 ;
179- let right = nums .length - 1 ;
180- while (left < right) {
181- const mid = (left + right) >> 1 ;
192+ let [l, r] = [0 , nums .length - 1 ];
193+ while (l < r) {
194+ const mid = (l + r) >> 1 ;
182195 if (nums[mid] >= target) {
183- right = mid;
196+ r = mid;
184197 } else {
185- left = mid + 1 ;
198+ l = mid + 1 ;
186199 }
187200 }
188- return nums[left ] == target ? left : - 1 ;
201+ return nums[l ] === target ? l : - 1 ;
189202};
190203```
191204
@@ -194,16 +207,16 @@ var search = function (nums, target) {
194207``` cs
195208public class Solution {
196209 public int Search (int [] nums , int target ) {
197- int left = 0 , right = nums .Length - 1 ;
198- while (left < right ) {
199- int mid = (left + right ) >> 1 ;
210+ int l = 0 , r = nums .Length - 1 ;
211+ while (l < r ) {
212+ int mid = (l + r ) >> 1 ;
200213 if (nums [mid ] >= target ) {
201- right = mid ;
214+ r = mid ;
202215 } else {
203- left = mid + 1 ;
216+ l = mid + 1 ;
204217 }
205218 }
206- return nums [left ] == target ? left : - 1 ;
219+ return nums [l ] == target ? l : - 1 ;
207220 }
208221}
209222```
0 commit comments