feat: 添加二分查找33,34,35,74

top-interview-leetcode150/binary-search/33搜索旋转排序数组.js

@@ -0,0 +1,46 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+const search = function (nums, target) {
+
+};
+
+/*
+思路：按照题目描述，数组旋转之后会变成两段有序的序列，而且第一段有序序列一定是大于第二段有序序列的
+可以直接利用二分查找，但是在查找的时候要留意mid落在那一段序列上，如果落在第一段序列上 nums[mid] >= nums[left],
+反之第二段，知道mid落在那一段序列之后，我们还需判断target在那一段序列上，如果mid在第一段，target也在第一段并且
+小于nums[mid]收缩右边界为mid-1，如果在第二段，收缩左边界为mid+1
+*/
+
+function f1(nums, target) {
+  let left = 0;
+  let right = nums.length - 1;
+
+  while (left <= right) {
+    const mid = left + ((right - left) >> 1);
+    if (nums[mid] === target) {
+      return mid; // 找到目标值，直接返回
+    }
+
+    // 如果mid落在第一段，那么nums[mid] >= nums[0], 否则落在第二段
+    if (nums[mid] >= nums[0]) {
+      // 如果target在第一段,并且target < nums[mid]
+      if (target > -nums[0] && target < nums[mid]) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
+      }
+    } else {
+      // 如果target落在第二段，并且target > nums[mid]
+      // eslint-disable-next-line no-lonely-if
+      if (target <= nums[nums.length - 1] && target > nums[mid]) {
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+  }
+  return -1; // 没有找到目标值
+}

top-interview-leetcode150/binary-search/34在排序数组中查找元素出现的范围.js

@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+const searchRange = function (nums, target) {
+
+};
+
+
+function searchRange(nums, target) {
+    let left = 0, right = nums.length - 1;
+    let start = -1, end = -1;
+
+    // Find the first occurrence
+    while (left <= right) {
+        let mid = Math.floor((left + right) / 2);
+        if (nums[mid] >= target) {
+            right = mid - 1;
+        } else {
+            left = mid + 1;
+        }
+    }
+    start = nums[left] === target ? left : -1;
+
+    // Find the last occurrence
+    left = 0;
+    right = nums.length - 1;
+    while (left <= right) {
+        let mid = Math.floor((left + right) / 2);
+        if (nums[mid] <= target) {
+            left = mid + 1;
+        } else {
+            right = mid - 1;
+        }
+    }
+    end = nums[right] === target ? right : -1;
+
+    return [start, end];
+}

top-interview-leetcode150/binary-search/35返回插入的位置.js

@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+const searchInsert = function (nums, target) {
+
+};
+
+/*
+直接利用二分查找
+*/
+  let pos = nums.length;
+  let left = 0;
+  let right = nums.length - 1;
+
+  // 二分查找知道left>right结束查找
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    // 如果target<nums[mid] 则更新pos
+    if (target === nums[mid]) return mid;
+
+    if (target < nums[mid]) {
+      pos = mid;
+      right = mid - 1;
+      continue;
+    }
+
+    left = mid + 1;
+  }
+
+  return pos;

top-interview-leetcode150/binary-search/74搜索二维矩阵.js

@@ -0,0 +1,67 @@
+/**
+ * @param {number[][]} matrix
+ * @param {number} target
+ * @return {boolean}
+ */
+const searchMatrix = function (matrix, target) {
+
+};
+
+/*
+将二维矩阵转换成一维数组，然后利用二分查找来查找目标值。
+*/
+function f1(matrix, target) {
+  const nums = matrix.flat(); // 将二维矩阵转换为一维数组
+  let left = 0;
+  let right = nums.length - 1;
+
+  while (left <= right) {
+    const mid = left + Math.floor(right - left) / 2;
+    if (nums[mid] === target) {
+      return true; // 找到目标值
+    } if (nums[mid] < target) {
+      left = mid + 1; // 目标值在右半部分
+    } else {
+      right = mid - 1; // 目标值在左半部分
+    }
+  }
+  return false; // 矩阵中没有这个值
+}
+
+/*
+两次二分查找，第一次找第一列中小于等于target的那个值，第二次找这一个值是否在这一行存在，存在返回true,不存在返回false
+*/
+function f2(matrix, target) {
+  // 二分查找第一列，这里使用upper_bound的方式
+  let left = 0;
+  let right = matrix.length;
+
+  while (left < right) {
+    const mid = left + Math.floor((right - left) / 2); // 使用靠右的计算防止死循环
+    if (matrix[mid][0] <= target) {
+      left = mid + 1;
+    } else {
+      right = mid;
+    }
+  }
+  const row = left - 1; // 右边界减1就是我们要找的值
+
+  // 如果右边界小于0表示要找的数不存在矩阵中，直接返回false
+  if (row < 0) return false;
+
+  // 二分查找这一行
+  left = 0;
+  right = matrix[row].length;
+  while (left <= right) {
+    const mid = left + Math.floor((right - left) / 2);
+    if (matrix[row][mid] === target) {
+      return true; // 找到目标值
+    } if (matrix[row][mid] < target) {
+      left = mid + 1; // 目标值在右半部分
+    } else {
+      right = mid - 1; // 目标值在左半部分
+    }
+  }
+
+  return false; // 矩阵中没有这个值
+}