feat: add solutions to lc problem: No.0167

No.0167.Two Sum II - Input Array Is Sorted

Author: yanglbme

solution/0100-0199/0167.Two Sum II - Input Array Is Sorted/README.md

@@ -55,242 +55,198 @@
 
 **方法一：二分查找**
 
-用指针 i 固定第一个数，然后二分查找 `[i + 1, n - 1]` 范围内是否存在 j，使得 `numbers[j] == target - numbers[i]`。
+注意到数组按照非递减顺序排列，因此对于每个 `numbers[i]`，可以通过二分查找的方式找到 `target - numbers[i]` 的位置，如果存在，那么返回 $[i + 1, j + 1]$ 即可。
 
-时间复杂度 O(nlogn)。
+时间复杂度 $O(n \times \log n)$，其中 $n$ 为数组 `numbers` 的长度。空间复杂度 $O(1)$。
 
 **方法二：双指针**
 
-初始时两个指针 i, j 分别指向数组的首尾位置。每次计算两指针对应的两个元素之和 x，判断 x 与 target 的大小关系：
+我们定义两个指针 $i$ 和 $j$，分别指向数组的第一个元素和最后一个元素。每次计算 $numbers[i] + numbers[j]$，如果和等于目标值，那么返回 $[i + 1, j + 1]$ 即可。如果和小于目标值，那么将 $i$ 右移一位，如果和大于目标值，那么将 $j$ 左移一位。
 
--   `x == target`，说明找到了答案，返回 `[i + 1, j + 1]`；
--   `x < target`，指针 i 右移；
--   `x > target`，指针 j 左移。
-
-若循环结束后依然没找到答案，则返回 `[-1, -1]`。
-
-时间复杂度 $O(n)$。
+时间复杂度 $O(n)$，其中 $n$ 为数组 `numbers` 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-二分查找：
-
 ```python
 class Solution:
     def twoSum(self, numbers: List[int], target: int) -> List[int]:
         n = len(numbers)
         for i in range(n - 1):
             x = target - numbers[i]
-            j = bisect.bisect_left(numbers, x, lo=i + 1)
-            if j != n and numbers[j] == x:
+            j = bisect_left(numbers, x, lo=i + 1)
+            if j < n and numbers[j] == x:
                 return [i + 1, j + 1]
-        return [-1, -1]
 ```
 
-双指针：
-
 ```python
 class Solution:
     def twoSum(self, numbers: List[int], target: int) -> List[int]:
-        i, j = 1, len(numbers)
+        i, j = 0, len(numbers) - 1
         while i < j:
-            x = numbers[i - 1] + numbers[j - 1]
+            x = numbers[i] + numbers[j]
             if x == target:
-                return [i, j]
+                return [i + 1, j + 1]
             if x < target:
                 i += 1
             else:
                 j -= 1
-        return [-1, -1]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-二分查找：
-
 ```java
 class Solution {
     public int[] twoSum(int[] numbers, int target) {
-        for (int i = 0, n = numbers.length; i < n - 1; ++i) {
+        for (int i = 0, n = numbers.length;; ++i) {
             int x = target - numbers[i];
-            int left = i + 1, right = n - 1;
-            while (left < right) {
-                int mid = (left + right) >> 1;
+            int l = i + 1, r = n - 1;
+            while (l < r) {
+                int mid = (l + r) >> 1;
                 if (numbers[mid] >= x) {
-                    right = mid;
+                    r = mid;
                 } else {
-                    left = mid + 1;
+                    l = mid + 1;
                 }
             }
-            if (numbers[left] == x) {
-                return new int[]{i + 1, left + 1};
+            if (numbers[l] == x) {
+                return new int[] {i + 1, l + 1};
             }
         }
-        return new int[]{-1, -1};
     }
 }
 ```
 
-双指针：
-
 ```java
 class Solution {
     public int[] twoSum(int[] numbers, int target) {
-        int i = 1, j = numbers.length;
-        while (i < j) {
-            int x = numbers[i - 1] + numbers[j - 1];
+        for (int i = 0, j = numbers.length - 1;;) {
+            int x = numbers[i] + numbers[j];
             if (x == target) {
-                return new int[] {i, j};
+                return new int[] {i + 1, j + 1};
             }
             if (x < target) {
                 ++i;
             } else {
                 --j;
             }
         }
-        return new int[] {-1, -1};
-    }
-}
-```
-
-### **TypeScript**
-
-二分查找：
-
-```ts
-function twoSum(numbers: number[], target: number): number[] {
-    for (let i = 0, n = numbers.length; i < n - 1; ++i) {
-        const x = target - numbers[i];
-        let left = i + 1,
-            right = n - 1;
-        while (left < right) {
-            const mid = (left + right) >> 1;
-            if (numbers[mid] >= x) {
-                right = mid;
-            } else {
-                left = mid + 1;
-            }
-        }
-        if (numbers[left] == x) {
-            return [i + 1, left + 1];
-        }
     }
-    return [-1, -1];
-}
-```
-
-双指针：
-
-```ts
-function twoSum(numbers: number[], target: number): number[] {
-    let i = 1,
-        j = numbers.length;
-    while (i < j) {
-        const x = numbers[i - 1] + numbers[j - 1];
-        if (x == target) {
-            return [i, j];
-        }
-        if (x < target) {
-            ++i;
-        } else {
-            --j;
-        }
-    }
-    return [-1, -1];
 }
 ```
 
 ### **C++**
 
-二分查找：
-
 ```cpp
 class Solution {
 public:
     vector<int> twoSum(vector<int>& numbers, int target) {
-        for (int i = 0, n = numbers.size(); i < n - 1; ++i) {
+        for (int i = 0, n = numbers.size();; ++i) {
             int x = target - numbers[i];
             int j = lower_bound(numbers.begin() + i + 1, numbers.end(), x) - numbers.begin();
-            if (j != n && numbers[j] == x) return {i + 1, j + 1};
+            if (j < n && numbers[j] == x) {
+                return {i + 1, j + 1};
+            }
         }
-        return {-1, -1};
     }
 };
 ```
 
-双指针：
-
 ```cpp
 class Solution {
 public:
     vector<int> twoSum(vector<int>& numbers, int target) {
-        int i = 1, j = numbers.size();
-        while (i < j)
-        {
-            int x = numbers[i - 1] + numbers[j - 1];
-            if (x == target) return {i, j};
-            if (x < target) ++i;
-            else --j;
+        for (int i = 0, j = numbers.size() - 1;;) {
+            int x = numbers[i] + numbers[j];
+            if (x == target) {
+                return {i + 1, j + 1};
+            }
+            if (x < target) {
+                ++i;
+            } else {
+                --j;
+            }
         }
-        return {-1, -1};
     }
 };
 ```
 
 ### **Go**
 
-二分查找：
-
 ```go
 func twoSum(numbers []int, target int) []int {
-	for i, n := 0, len(numbers); i < n-1; i++ {
+	for i, n := 0, len(numbers); ; i++ {
 		x := target - numbers[i]
-		left, right := i+1, n-1
-		for left < right {
-			mid := (left + right) >> 1
-			if numbers[mid] >= x {
-				right = mid
-			} else {
-				left = mid + 1
-			}
-		}
-		if numbers[left] == x {
-			return []int{i + 1, left + 1}
+		j := sort.SearchInts(numbers[i+1:], x) + i + 1
+		if j < n && numbers[j] == x {
+			return []int{i + 1, j + 1}
 		}
 	}
-	return []int{-1, -1}
 }
 ```
 
-双指针：
-
 ```go
 func twoSum(numbers []int, target int) []int {
-	i, j := 1, len(numbers)
-	for i < j {
-		x := numbers[i-1] + numbers[j-1]
+	for i, j := 0, len(numbers)-1; ; {
+		x := numbers[i] + numbers[j]
 		if x == target {
-			return []int{i, j}
+			return []int{i + 1, j + 1}
 		}
 		if x < target {
 			i++
 		} else {
 			j--
 		}
 	}
-	return []int{-1, -1}
 }
 ```
 
-### **JavaScript**
+### **TypeScript**
+
+```ts
+function twoSum(numbers: number[], target: number): number[] {
+    const n = numbers.length;
+    for (let i = 0; ; ++i) {
+        const x = target - numbers[i];
+        let l = i + 1;
+        let r = n - 1;
+        while (l < r) {
+            const mid = (l + r) >> 1;
+            if (numbers[mid] >= x) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        if (numbers[l] === x) {
+            return [i + 1, l + 1];
+        }
+    }
+}
+```
 
-二分查找：
+```ts
+function twoSum(numbers: number[], target: number): number[] {
+    for (let i = 0, j = numbers.length - 1; ; ) {
+        const x = numbers[i] + numbers[j];
+        if (x === target) {
+            return [i + 1, j + 1];
+        }
+        if (x < target) {
+            ++i;
+        } else {
+            --j;
+        }
+    }
+}
+```
+
+### **JavaScript**
 
 ```js
 /**
@@ -299,49 +255,44 @@ func twoSum(numbers []int, target int) []int {
  * @return {number[]}
  */
 var twoSum = function (numbers, target) {
-    for (let i = 0, n = numbers.length; i < n - 1; ++i) {
+    const n = numbers.length;
+    for (let i = 0; ; ++i) {
         const x = target - numbers[i];
-        let left = i + 1,
-            right = n - 1;
-        while (left < right) {
-            const mid = (left + right) >> 1;
+        let l = i + 1;
+        let r = n - 1;
+        while (l < r) {
+            const mid = (l + r) >> 1;
             if (numbers[mid] >= x) {
-                right = mid;
+                r = mid;
             } else {
-                left = mid + 1;
+                l = mid + 1;
             }
         }
-        if (numbers[left] == x) {
-            return [i + 1, left + 1];
+        if (numbers[l] === x) {
+            return [i + 1, l + 1];
         }
     }
-    return [-1, -1];
 };
 ```
 
-双指针：
-
 ```js
 /**
  * @param {number[]} numbers
  * @param {number} target
  * @return {number[]}
  */
 var twoSum = function (numbers, target) {
-    let i = 1,
-        j = numbers.length;
-    while (i < j) {
-        const x = numbers[i - 1] + numbers[j - 1];
-        if (x == target) {
-            return [i, j];
+    for (let i = 0, j = numbers.length - 1; ; ) {
+        const x = numbers[i] + numbers[j];
+        if (x === target) {
+            return [i + 1, j + 1];
         }
         if (x < target) {
             ++i;
         } else {
             --j;
         }
     }
-    return [-1, -1];
 };
 ```