Update README_EN.md

Author: yanglbme

solution/0700-0799/0704.Binary Search/README_EN.md

@@ -56,16 +56,16 @@ tags:
 
 ### Solution 1: Binary Search
 
-We define the left boundary of the binary search as $left=0$, and the right boundary as $right=n-1$.
+We define the left boundary $l=0$ and the right boundary $r=n-1$ for binary search.
 
-In each iteration, we calculate the middle position $mid=(left+right)/2$, and then compare the size of $nums[mid]$ and $target$:
+In each iteration, we calculate the middle position $\text{mid}=(l+r)/2$, then compare the size of $\text{nums}[\text{mid}]$ and $\text{target}$.
 
--   If $nums[mid] \geq target$, it means that $target$ is in the interval $[left, mid]$, so we update $right$ to $mid$;
--   Otherwise, $target$ is in the interval $[mid+1, right]$, so we update $left$ to $mid+1$.
+-   If $\text{nums}[\text{mid}] \geq \text{target}$, it means $\text{target}$ is in the left half, so we move the right boundary $r$ to $\text{mid}$;
+-   Otherwise, it means $\text{target}$ is in the right half, so we move the left boundary $l$ to $\text{mid}+1$.
 
-When $left \geq right$, we check if $nums[left]$ equals $target$. If it does, we return $left$, otherwise, we return $-1$.
+The loop ends when $l<r$, at this point $\text{nums}[l]$ is the target value we are looking for. If $\text{nums}[l]=\text{target}$, return $l$; otherwise, return $-1$.
 
-The time complexity is $O(\log n)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$.
+The time complexity is $O(\log n)$, where $n$ is the length of the array $\text{nums}$. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -74,31 +74,31 @@ The time complexity is $O(\log n)$, where $n$ is the length of the array $nums$.
 ```python
 class Solution:
     def search(self, nums: List[int], target: int) -> int:
-        left, right = 0, len(nums) - 1
-        while left < right:
-            mid = (left + right) >> 1
+        l, r = 0, len(nums) - 1
+        while l < r:
+            mid = (l + r) >> 1
             if nums[mid] >= target:
-                right = mid
+                r = mid
             else:
-                left = mid + 1
-        return left if nums[left] == target else -1
+                l = mid + 1
+        return l if nums[l] == target else -1
 ```
 
 #### Java
 
 ```java
 class Solution {
     public int search(int[] nums, int target) {
-        int left = 0, right = nums.length - 1;
-        while (left < right) {
-            int mid = (left + right) >> 1;
+        int l = 0, r = nums.length - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
             if (nums[mid] >= target) {
-                right = mid;
+                r = mid;
             } else {
-                left = mid + 1;
+                l = mid + 1;
             }
         }
-        return nums[left] == target ? left : -1;
+        return nums[l] == target ? l : -1;
     }
 }
 ```
@@ -109,15 +109,16 @@ class Solution {
 class Solution {
 public:
     int search(vector<int>& nums, int target) {
-        int left = 0, right = nums.size() - 1;
-        while (left < right) {
-            int mid = left + right >> 1;
-            if (nums[mid] >= target)
-                right = mid;
-            else
-                left = mid + 1;
+        int l = 0, r = nums.size() - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (nums[mid] >= target) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
         }
-        return nums[left] == target ? left : -1;
+        return nums[l] == target ? l : -1;
     }
 };
 ```
@@ -126,46 +127,59 @@ public:
 
 ```go
 func search(nums []int, target int) int {
-	left, right := 0, len(nums)-1
-	for left < right {
-		mid := (left + right) >> 1
+	l, r := 0, len(nums)-1
+	for l < r {
+		mid := (l + r) >> 1
 		if nums[mid] >= target {
-			right = mid
+			r = mid
 		} else {
-			left = mid + 1
+			l = mid + 1
 		}
 	}
-	if nums[left] == target {
-		return left
+	if nums[l] == target {
+		return l
 	}
 	return -1
 }
 ```
 
+#### TypeScript
+
+```ts
+function search(nums: number[], target: number): number {
+    let [l, r] = [0, nums.length - 1];
+    while (l < r) {
+        const mid = (l + r) >> 1;
+        if (nums[mid] >= target) {
+            r = mid;
+        } else {
+            l = mid + 1;
+        }
+    }
+    return nums[l] === target ? l : -1;
+}
+```
+
 #### Rust
 
 ```rust
-use std::cmp::Ordering;
-
 impl Solution {
     pub fn search(nums: Vec<i32>, target: i32) -> i32 {
-        let mut l = 0;
-        let mut r = nums.len();
+        let mut l: usize = 0;
+        let mut r: usize = nums.len() - 1;
         while l < r {
             let mid = (l + r) >> 1;
-            match nums[mid].cmp(&target) {
-                Ordering::Less => {
-                    l = mid + 1;
-                }
-                Ordering::Greater => {
-                    r = mid;
-                }
-                Ordering::Equal => {
-                    return mid as i32;
-                }
+            if nums[mid] >= target {
+                r = mid;
+            } else {
+                l = mid + 1;
             }
         }
-        -1
+        if nums[l] == target {
+            l as i32
+        } else {
+            -1
+        }
     }
 }
 ```
@@ -179,53 +193,34 @@ impl Solution {
  * @return {number}
  */
 var search = function (nums, target) {
-    let left = 0;
-    let right = nums.length - 1;
-    while (left < right) {
-        const mid = (left + right) >> 1;
+    let [l, r] = [0, nums.length - 1];
+    while (l < r) {
+        const mid = (l + r) >> 1;
         if (nums[mid] >= target) {
-            right = mid;
+            r = mid;
         } else {
-            left = mid + 1;
+            l = mid + 1;
         }
     }
-    return nums[left] == target ? left : -1;
+    return nums[l] === target ? l : -1;
 };
 ```
 
-#### TypeScript
-
-```ts
-function search(nums: number[], target: number): number {
-    let [l, r] = [0, nums.length - 1];
-
-    while (l <= r) {
-        const mid = (l + r) >> 1;
-
-        if (nums[mid] === target) return mid;
-        if (nums[mid] < target) l = mid + 1;
-        else r = mid - 1;
-    }
-
-    return -1;
-}
-```
-
 #### C#
 
 ```cs
 public class Solution {
     public int Search(int[] nums, int target) {
-        int left = 0, right = nums.Length - 1;
-        while (left < right) {
-            int mid = (left + right) >> 1;
+        int l = 0, r = nums.Length - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
             if (nums[mid] >= target) {
-                right = mid;
+                r = mid;
             } else {
-                left = mid + 1;
+                l = mid + 1;
             }
         }
-        return nums[left] == target ? left : -1;
+        return nums[l] == target ? l : -1;
     }
 }
 ```