feat(binary-search): 📝总结二分搜索简单篇

Author: descire

Binary-Search/367.png

@@ -9,25 +9,18 @@
  * 33.8mb 79.73%
  */
 const isPerfectSquare = num => {
-  // 边界情况
-  if (num === 1) {
-    return true
-  }
-  let first = 1
-  let last = num
+  let start = 1
+  let end = num
 
-  while (first < last) {
-    const mid = Math.floor(first + (last - first) / 2)
-    const ret = mid * mid
-    if (ret === num) {
-      return true
-    }
-    if (ret > num) {
-      last = mid
+  while (start < end) {
+    const mid = Math.floor(start + (end - start) / 2)
+    const middle = mid * mid
+    if (num > middle) {
+      start = mid + 1
     } else {
-      first = mid + 1
+      end = mid
     }
   }
 
-  return false
+  return start ** 2 === num
 }

Binary-Search/367/solution1.js

@@ -12,25 +12,20 @@
  */
 
 const arrangeCoins = n => {
-  // 边界情况
-  if (n === 0) {
-    return 0
-  }
-  if (n === 1) {
-    return 1
-  }
-  let first = 0
-  let last = n
-  let ret = 0
-  while (first < last) {
-    const mid = Math.floor(first + (last - first) / 2)
+  let start = 0
+  let end = n
+  while (start < end) {
+    const mid = Math.floor(start + (end - start) / 2)
     const target = (mid + 1) * mid / 2
-    if (target > n) {
-      last = mid
+    if (n > target) {
+      start = mid + 1
     } else {
-      first = mid + 1
+      end = mid
     }
   }
 
-  return first - 1
+  if ((start + 1) * start / 2 > n) {
+    return start - 1
+  }
+  return start
 }

Binary-Search/441/solution1.js

@@ -1,11 +1,10 @@
 /**
- * https://leetcode.com/problems/heaters/
  * 
  * 475. Heaters
  * 
  * Easy
  * 
- * 112ms 90.01%
+ * 184ms 100.00%
  * 39mb 74.45%
  */
 const findRadius = (houses, heaters) => {
@@ -16,14 +15,15 @@ const findRadius = (houses, heaters) => {
 
   for (let i = 0, max = houses.length; i < max; i++) {
     const house = houses[i]
-    const first = binarySearch(heaters, 0, len - 1, house)
+    const targetPos = binarySearch(heaters, 0, len - 1, house)
     let closestDistance = Number.MAX_SAFE_INTEGER
-    if (first === undefined) {
+    if (heaters[targetPos] === house) {
       ans = Math.max(ans, 0)
       continue
     }
-    const pre = heaters[first - 1]
-    const cur = heaters[first]
+    // 比较前一个 和 后一个 得到最小值
+    const pre = heaters[targetPos - 1]
+    const cur = heaters[targetPos]
     if (pre !== undefined) {
       closestDistance = Math.min(closestDistance, Math.abs(house - pre))
     }
@@ -35,18 +35,15 @@ const findRadius = (houses, heaters) => {
   return ans
 }
 
-function binarySearch(array, first, last, target) {
-  while (first < last) {
-    const mid = Math.floor(first + (last - first) / 2)
-    const t = array[mid]
-    if (t === target) {
-      return undefined
-    }
-    if (t > target) {
-      last = mid
+function binarySearch(array, start, end, target) {
+  while (start < end) {
+    const mid = Math.floor(start + (end - start) / 2)
+    const middle = array[mid]
+    if (target > middle) {
+      start = mid + 1
     } else {
-      first = mid + 1
+      end = mid
     }
   }
-  return first
+  return start
 }

Binary-Search/475.png

@@ -9,24 +9,20 @@
  * 35.7mb 47.66%
  */
 const mySqrt = x => {
-  if (x === 1) {
-    return 1
-  }
-  let first = 1
-  let last = x
+  let start = 1
+  let end = x
 
-  while (first < last) {
-    const mid = Math.floor(first + (last - first) / 2)
-    const target = mid * mid
-    if (target === x) {
-      return mid
-    }
-    if (target > x) {
-      last = mid
+  while (start < end) {
+    const mid = Math.floor(start + (end - start) / 2)
+    const middle = mid * mid
+    if (x > middle) {
+      start = mid + 1
     } else {
-      first = mid + 1
+      end = mid
     }
   }
-
-  return first - 1
+  if (start ** 2 === x) {
+    return start
+  }  
+  return start - 1
 }

Binary-Search/475/solution1.js

@@ -12,15 +12,15 @@ const peakIndexInMountainArray = A => {
   return binarySearch(A, 0, A.length - 1)
 }
 
-function binarySearch(array, first, end) {
-  while (first < end - 1) {
-    const mid = Math.floor(first + (end - first) / 2) // 数组下标注意整数
+function binarySearch(array, start, end) {
+  while (start < end) {
+    const mid = Math.floor(start + (end - start) / 2)
     if (array[mid + 1] > array[mid]) {
-      first = mid
+      start = mid + 1
     } else {
       end = mid
     }
   }
 
-  return (array[first] > array[end] ? first : end)
+  return start
 }

Binary-Search/69/solution1.js

@@ -0,0 +1,17 @@
+function binarySearch(arr, target) {
+  let start = 0
+  let end = arr.length - 1
+
+  while (start < end) {
+    const mid = Math.floor(start + (end - start) / 2)
+    if (arr[mid] < target) {
+      start = mid + 1
+    } else {
+      end = mid
+    }
+  }
+  
+  return start
+}
+
+console.log(binarySearch([0, 1, 2, 3, 4, 5], 5))

Binary-Search/744.png

@@ -0,0 +1,88 @@
+# 一只前端的 LeetCode 之旅 -- 二分搜索（Easy篇）
+
+### 一、二分搜索算法
+
+##### 1、基本认知
+
+    二分搜索是一种在有序数组中查找某一特定元素的搜索算法。
+
+  ![二分搜索](./Binary_search_into_array.png)
+
+    二分搜索算法的时间复杂度为 O(log n)，相比较顺序搜索的 O(n) 时间复杂度，它是非常快的。
+
+    例如，在一个长度为一百万的有序数组中，采用顺序搜索，最坏的情况需要执行一百万次，而二分搜索算法则只需要二十次！
+
+    从上图中，读者可以发现，二分搜索的关键就是通过目标值与中间值的比较，将搜索区间缩小一半，这也是为什么有序数组是二分搜索算法的重要前提。
+
+##### 2、代码实现
+
+    由前文可知，二分搜索并不是一个特别的复杂的算法，但是想通过代码实现它，并不是一件易事。
+
+    一般二分搜索都是作用于数组上，所以要先求出数组的中间下标（整数），从而获取到中间值：
+
+```JavaScript
+  const mid = Math.floor((start + end) / 2)
+```
+
+    读者可能第一时间想到的就是上述写法，但是在一些极端的情况，start + end 可能直接超出最大的安全整数，所以更加的谨慎的写法如下：
+
+```JavaScript
+  const mid = Math.floor(start + (end - start) / 2)
+```
+
+    最后就是搜索区间如何不断缩小一半，对于很多初学者来说，经常会将其写成一个死循环，这里保持搜索区间左闭右开的写法：
+
+```JavaScript
+while (start < end) {
+  const mid = Math.floor(start + (end - start) / 2)
+  if (arr[mid] < target) {
+    start = mid + 1
+  } else {
+    end = mid
+  }
+}
+```
+
+### 二、LeetCode 实战
+
+##### 1、744. 寻找比目标字母大的最小字母
+
+  &emsp;&emsp;这道题目主要考察二分搜索算法的基本实现：
+
+  ![744解题代码](./744.png)
+
+##### 2、367. 有效的完全平方数
+
+  &emsp;&emsp;这道题目需要如下两个技巧：
+  
+- 如果 num 为完全平方数，那么能形成该完全平方数的整数必定存在 [1, num) 区间，是不是有序数组的前提条件有了；
+- 取得 [1, num) 区间的中间值时，需要进行平方运算后再与 num 比较；
+
+  ![367解题代码](./367.png)
+
+&emsp;&emsp;类似解题思路的题目还有[【69. x 的平方根】](https://leetcode-cn.com/problems/sqrtx/)和[【441. 排列硬币】](https://leetcode-cn.com/problems/arranging-coins/)。
+
+##### 3、852. 山脉数组的峰顶索引
+
+  &emsp;&emsp;仔细读题之后，你会发现给定的数组并非有序数组，但是需要查找目标数字恰巧处于一个很特殊的位置，当我们从当前区间查找到中间值时，可以通过与前一个数或者后一个数的比较，可以判断当前中间值处于递增还是递减区间，从而判断峰值处于左半区间还是右半区间：
+
+  ![852解题代码](./852.png)
+
+##### 6、475. 供暖器
+
+  &emsp;&emsp;这道题的难点在于是否读懂了题目：找到一个最小半径使得加热器覆盖所有房子。
+
+  &emsp;&emsp;那么最简单的解法就是遍历所有的房子的同时，遍历加热器找出距离该房子的最小距离，那么所有房子中的最大距离即为加热器覆盖的最小半径，那么整个过程的时间复杂度就是 O(n*m)，对于加热器的搜索可以采用二分搜索算法优化，那么时间复杂度可以优化为 O(nlog m):
+
+  ![475解题代码](./475.png)
+
+
+### 写在最后
+
+  &emsp;&emsp;算法作为计算机的基础学科，用 JavaScript 刷，一点也不丢人ε=ε=ε=┏(゜ロ゜;)┛。
+
+  &emsp;&emsp;本系列文章会分别给出一种算法的3种难度的总结篇（简单难度，中等难度以及困难难度），如果本文对您有所帮助，可以点赞或者关注来鼓励博主。
+  
+
+- [一只前端的 LeetCode 之旅](https://github.com/15751165579/LeetCode)
+

Binary-Search/852.png

@@ -6,12 +6,12 @@
 
 | 题目 | 难度 | 代码 | beats Runtime | beats Memory | 时间复杂度 |
 | :----- | :---: | :---: | :---: | :---: | :--: |
-| [852. Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/) | Easy | [解题代码](/Binary-Search/852/solution2.js) | **98.70%** | **72.89%** | O(log n)|
-| [744. Find Smallest Letter Greater Than Target](https://leetcode.com/problems/find-smallest-letter-greater-than-target/) | Easy | [解题代码](/Binary-Search/744/solution1.js) | **100.00%** | **72.67%** | O(log n)|
-| [367. Valid Perfect Square](https://leetcode.com/problems/valid-perfect-square/) | Easy | [解题代码](/Binary-Search/744/solution1.js) | **99.67%** | **79.73%** | O(log n)|
-| [441. Arranging Coins](https://leetcode.com/problems/arranging-coins/) | Easy | [解题代码](/Binary-Search/441/solution1.js) | **100.00%** | **90.18%** | O(log n)|
-| [475. Heaters](https://leetcode.com/problems/heaters/) | Easy | [解题代码](/Binary-Search/441/solution1.js) | **90.01%** | **74.45%** | O(nlog n)|
-| [69. Sqrt(x)](https://leetcode.com/problems/sqrtx/) | Easy | [解题代码](/Binary-Search/441/solution1.js) | **96.10%** | **47.66%** | O(log n)|
+| [852. 山脉数组的峰顶索引](https://leetcode-cn.com/problems/peak-index-in-a-mountain-array/submissions/) | Easy | [解题代码](/Binary-Search/852/solution2.js) | **98.70%** | **72.89%** | O(log n)|
+| [744. 寻找比目标字母大的最小字母](https://leetcode-cn.com/problems/find-smallest-letter-greater-than-target/) | Easy | [解题代码](/Binary-Search/744/solution1.js) | **100.00%** | **72.67%** | O(log n)|
+| [367. 有效的完全平方数](https://leetcode-cn.com/problems/valid-perfect-square/) | Easy | [解题代码](/Binary-Search/744/solution1.js) | **99.67%** | **79.73%** | O(log n)|
+| [441. 排列硬币](https://leetcode-cn.com/problems/arranging-coins/) | Easy | [解题代码](/Binary-Search/441/solution1.js) | **100.00%** | **90.18%** | O(log n)|
+| [475. 供暖器](https://leetcode-cn.com/problems/heaters/) | Easy | [解题代码](/Binary-Search/441/solution1.js) | **90.01%** | **74.45%** | O(nlog m)|
+| [69. x 的平方根](https://leetcode-cn.com/problems/sqrtx/) | Easy | [解题代码](/Binary-Search/441/solution1.js) | **96.10%** | **47.66%** | O(log n)|
 | [378. Kth Smallest Element in a Sorted Matrix](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/) | Medium | [解题代码](/Binary-Search/378/solution2.js) | **97.86%** | **73.13%** | O(nlog n)|
 | [875. Koko Eating Bananas](https://leetcode.com/problems/koko-eating-bananas/) | Medium | [解题代码](/Binary-Search/875/solution2.js) | **91.82%** | **71.83%** | O(nlog n)|
 | [436. Find Right Interval](https://leetcode.com/problems/find-right-interval/) | Medium | [解题代码](/Binary-Search/436/solution2.js) | **100.00%** | **60.00%** | O(nlog n)|