添加题35，74，278

Author: ligecarryme

README.md

@@ -10,11 +10,19 @@
 
 ## 核心内容
 
-#### 数据结构篇 🐢
+### 数据结构篇 🐰
 
 - [二叉树](https://github.com/ligecarryme/algorithm-pattern-JavaScript/blob/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%AF%87/%E4%BA%8C%E5%8F%89%E6%A0%91.md)
 - [链表](https://github.com/ligecarryme/algorithm-pattern-JavaScript/blob/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%AF%87/%E9%93%BE%E8%A1%A8.md)
 
 - [栈和队列](https://github.com/ligecarryme/algorithm-pattern-JavaScript/blob/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%AF%87/%E6%A0%88%E5%92%8C%E9%98%9F%E5%88%97.md)
 - [二进制](https://github.com/ligecarryme/algorithm-pattern-JavaScript/blob/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%AF%87/%E4%BA%8C%E8%BF%9B%E5%88%B6.md)
 
+### 基础算法篇 🐮
+
+- [二分搜索](https://github.com/ligecarryme/algorithm-pattern-JavaScript/blob/master/%E5%9F%BA%E7%A1%80%E7%AE%97%E6%B3%95%E7%AF%87/%E4%BA%8C%E5%88%86%E6%90%9C%E7%B4%A2.md)
+- [排序算法](https://github.com/ligecarryme/algorithm-pattern-JavaScript/blob/master/%E5%9F%BA%E7%A1%80%E7%AE%97%E6%B3%95%E7%AF%87/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95.md)
+- [动态规划](https://github.com/ligecarryme/algorithm-pattern-JavaScript/blob/master/%E5%9F%BA%E7%A1%80%E7%AE%97%E6%B3%95%E7%AF%87/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92.md)
+
+### 算法思维篇 🦁
+

基础算法篇/二分搜索.md

@@ -11,9 +11,9 @@
 - 3、比较中点和目标值：A[mid] ==、 <、> target
 - 4、判断最后两个元素是否符合：A[start]、A[end] ? target
 
-时间复杂度 O(logn)，使用场景一般是有序数组的查找
+时间复杂度 O(logn)，使用场景一般是有序数组的查找。
 
-##### 704.二分查找 [binary-search](https://leetcode-cn.com/problems/binary-search/)
+##### [704.二分查找(经典示例)](https://leetcode-cn.com/problems/binary-search/)
 
 ```js
 // 二分搜索最常用模板
@@ -43,28 +43,30 @@ var search = function(nums, target) {
 
 大部分二分查找类的题目都可以用这个模板，然后做一点特殊逻辑即可。
 
-**模板 #1** (left <= right)
+**模板 #1** `(left <= right)`
 
 二分查找的最基础和最基本的形式。
 查找条件可以在不与元素的两侧进行比较的情况下确定（或使用它周围的特定元素）。
 不需要后处理，因为每一步中，你都在检查是否找到了元素。如果到达末尾，则知道未找到该元素。
 
-**模板 #2** (left < right)
+**模板 #2** `(left < right)`
 
 一种实现二分查找的高级方法。
 查找条件需要访问元素的直接右邻居。
 使用元素的右邻居来确定是否满足条件，并决定是向左还是向右。
 保证查找空间在每一步中至少有 2 个元素。
 需要进行后处理。 当你剩下 1 个元素时，循环 / 递归结束。 需要评估剩余元素是否符合条件。
 
-**模板 #3** (left + 1 < right)
+**模板 #3** `(left + 1 < right)`
 
 实现二分查找的另一种方法。
 搜索条件需要访问元素的直接左右邻居。
 使用元素的邻居来确定它是向右还是向左。
 保证查找空间在每个步骤中至少有 3 个元素。
 需要进行后处理。 当剩下 2 个元素时，循环 / 递归结束。 需要评估其余元素是否符合条件。
 
+![](https://camo.githubusercontent.com/b3228d92578552d9098924866218c3183e3ae63d66d46a9d156e478329344206/68747470733a2f2f696d672e667569626f6f6d2e636f6d2f696d672f62696e6172795f7365617263685f74656d706c6174652e706e67)
+
 如果是最简单的二分搜索，不需要找第一个、最后一个位置、或者是没有重复元素，可以使用**模板#1**，代码更简洁：
 
 ```js
@@ -93,11 +95,9 @@ var search = function(nums, target) {
 };
 ```
 
-##### 34.在排序数组中查找元素的第一个和最后一个位置 [find-first-and-last-position-of-element-in-sorted-array](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/)
-
-给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
+##### [34.在排序数组中查找元素的第一个和最后一个位置](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/)
 
-如果数组中不存在目标值 target，返回 [-1, -1]。
+给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。
 
 **进阶：**
 
@@ -151,3 +151,86 @@ var searchRange = function(nums, target) {
 };
 ```
 
+##### [35. 搜索插入位置](https://leetcode-cn.com/problems/search-insert-position/)
+
+给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
+
+```js
+var searchInsert = function (nums, target) {
+    let left = 0, mid = 0, right = nums.length - 1
+    let res = 0
+    while (left + 1 < right) {
+        mid = left + ((right - left) >> 1)
+        if (nums[mid] < target) {
+            left = mid
+        } else {
+            right = mid
+        }
+    }
+    if (target <= nums[left]) {
+        return left
+    } else if (target <= nums[right]) {
+        return right
+    } else {
+        return right + 1
+    }
+};
+```
+
+##### [74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/)
+
+编写一个高效的算法来判断 `m x n` 矩阵中，是否存在一个目标值。
+
+```js
+var searchMatrix = function (matrix, target) {
+    let row = matrix.length
+    let col = matrix[0].length
+    let start = 0
+    let end = row * col - 1
+    let mid = 0
+    while (start + 1 < end) {
+        mid = start + ((end - start) >> 1)
+        val = matrix[parseInt(mid / col)][mid % col]
+        if (val > target) {
+            end = mid
+        } else if (val < target) {
+            start = mid
+        } else {
+            return true
+        }
+    }
+    if (matrix[parseInt(start / col)][start % col] === target || matrix[parseInt(end / col)][end % col] === target) {
+        return true
+    }
+    return false
+};
+```
+
+##### [278. 第一个错误的版本](https://leetcode-cn.com/problems/first-bad-version/)
+
+```js
+var solution = function (isBadVersion) {
+    /**
+     * @param {integer} n Total versions
+     * @return {integer} The first bad version
+     */
+    return function (n) {
+        let start = 1
+        let end = n
+        let mid = 1
+        while (start + 1 < end) {
+            mid = start + ((end - start) >> 1)
+            if(isBadVersion(mid)){
+                end = mid
+            } else {
+                start = mid
+            }
+        }
+        if(isBadVersion(start)){
+            return start
+        }
+        return end
+    };
+};
+```
+