add T704,T34,T137,T155

Author: ligecarryme

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

@@ -0,0 +1,153 @@
+### 二分搜索
+
+#### 二分搜索模板
+
+给一个**有序数组**和目标值，找第一次/最后一次/任何一次出现的索引，如果没有出现返回-1
+
+模板四点要素
+
+- 1、初始化：start=0、end=len-1
+- 2、循环条件：start <= end
+- 3、比较中点和目标值：A[mid] ==、 <、> target
+- 4、判断最后两个元素是否符合：A[start]、A[end] ? target
+
+时间复杂度 O(logn)，使用场景一般是有序数组的查找
+
+##### 704.二分查找 [binary-search](https://leetcode-cn.com/problems/binary-search/)
+
+```js
+// 二分搜索最常用模板
+var search = function(nums, target) {
+    let left = 0, mid = 0, right = nums.length-1;
+    while(left + 1 < right){
+        mid = left + ((right-left) >> 2);
+        if(nums[mid] === target){
+            return mid;
+        }
+        if(nums[mid] > target){
+            right = mid - 1;
+        } else {
+            left = mid + 1;
+        }
+    }
+ 	// 最后剩下两个元素，手动判断
+    if (nums[left] === target) {
+        return left;
+    }
+    if (nums[right] === target) {
+        return right;
+    }
+    return -1;
+};
+```
+
+大部分二分查找类的题目都可以用这个模板，然后做一点特殊逻辑即可。
+
+**模板 #1** (left <= right)
+
+二分查找的最基础和最基本的形式。
+查找条件可以在不与元素的两侧进行比较的情况下确定（或使用它周围的特定元素）。
+不需要后处理，因为每一步中，你都在检查是否找到了元素。如果到达末尾，则知道未找到该元素。
+
+**模板 #2** (left < right)
+
+一种实现二分查找的高级方法。
+查找条件需要访问元素的直接右邻居。
+使用元素的右邻居来确定是否满足条件，并决定是向左还是向右。
+保证查找空间在每一步中至少有 2 个元素。
+需要进行后处理。 当你剩下 1 个元素时，循环 / 递归结束。 需要评估剩余元素是否符合条件。
+
+**模板 #3** (left + 1 < right)
+
+实现二分查找的另一种方法。
+搜索条件需要访问元素的直接左右邻居。
+使用元素的邻居来确定它是向右还是向左。
+保证查找空间在每个步骤中至少有 3 个元素。
+需要进行后处理。 当剩下 2 个元素时，循环 / 递归结束。 需要评估其余元素是否符合条件。
+
+如果是最简单的二分搜索，不需要找第一个、最后一个位置、或者是没有重复元素，可以使用**模板#1**，代码更简洁：
+
+```js
+var search = function(nums, target) {
+    let start = 0, mid = 0, end = nums.length-1;
+    while(start <= end){
+        mid = start + ((start+end)>>2);
+        if(nums[mid] === target){
+            return mid;
+        }
+        if(nums[mid] > target){
+            end = mid - 1;
+        } else {
+            start = mid + 1;
+        }
+    }
+    return -1;
+};
+```
+
+JS 用 indexOf 也可以：
+
+```js
+var search = function(nums, target) {
+    return nums.indexOf(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。找出给定目标值在数组中的开始位置和结束位置。
+
+如果数组中不存在目标值 target，返回 [-1, -1]。
+
+**进阶：**
+
+- 你可以设计并实现时间复杂度为 `O(log n)` 的算法解决此问题吗？
+
+> 输入：nums = [5,7,7,8,8,10], target = 8
+> 输出：[3,4]
+
+```js
+var searchRange = function(nums, target) {
+    if(target<nums[0] || target>nums[nums.length-1]){
+        return [-1,-1];
+    }
+    let res = [-1,-1];
+    let left = 0, mid = 0, right = nums.length-1;
+    while(left <= right){
+        mid = left + ((right-left) >> 1);
+        if(nums[mid] >= target){
+            if(mid === 0 || (nums[mid] === target && nums[mid-1]<target)){
+                res[0] = mid;
+                break;
+            }else{
+                right = mid - 1;
+            }
+        }else{
+            left = mid + 1;
+        }
+    }
+    if(res[0]!==-1 && nums[res[0]]===target){
+        if(res[0]===nums.length-1){
+            res[1] = res[0];
+        } else {
+            for(let i=res[0]+1;i<nums.length;i++){
+                if(nums[i] !== target){
+                    res[1] = i-1;
+                    break;
+                }
+                if(i===nums.length-1 && nums[i]===target){
+                    res[1] = i;
+                }
+            }
+        }
+    }
+    return res;
+};
+```
+
+```js
+var searchRange = function(nums, target) {
+    return [nums.indexOf(target),nums.lastIndexOf(target)]; //使用内置方法，运行更快
+};
+```
+

数据结构篇/二叉树.md

@@ -1,14 +1,17 @@
-104.二叉树的最大深度[二叉树的最大深度](https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/)
+### 二叉树
+
+##### 104.二叉树的最大深度[二叉树的最大深度](https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/)
 
 给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。**说明:** 叶子节点是指没有子节点的节点。
 
 > 给定二叉树 [3,9,20,null,null,15,7]，
 >
->         3
->        / \
->       9  20
->         /  \
->        15   7
+>       3
+>      / \
+>     9  20
+>       /  \
+>      15   7
+>
 > 返回它的最大深度 3 。
 
 ```js

数据结构篇/二进制.md

@@ -0,0 +1,43 @@
+### 二进制
+
+JS二进制基础知识： [二进制](https://wangdoc.com/javascript/operators/bit.html)
+
+##### 136.只出现一次的数字 [single-number](https://leetcode-cn.com/problems/single-number/)
+
+给定一个**非空**整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
+
+> 输入: [2,2,1]
+> 输出: 1
+>
+> 4 ^ 1 ^ 2 ^ 1 ^ 2 = 4
+
+思路：a === a ^ b ^ b   
+
+```js
+var singleNumber = function(nums) {
+    let res = 0;
+    for(let num of nums){
+        res ^= num;
+    }
+    return res;
+};
+```
+
+##### 137.只出现一次的数字 II  [single-number-ii](https://leetcode-cn.com/problems/single-number-ii/)
+
+给定一个**非空**整数数组，除了某个元素只出现一次以外，其余每个元素均出现了三次。找出那个只出现了一次的元素。
+
+> 输入: [2,2,3,2]
+> 输出: 3
+
+```js
+var singleNumber = function(nums) {
+    let seenOnce = 0, seenTwice = 0;
+    for(let num of nums){
+        seenOnce = ~seenTwice & (seenOnce ^ num);
+        seenTwice = ~seenOnce & (seenTwice ^ num);
+    }
+    return seenOnce;
+};
+```
+

数据结构篇/栈和队列.md

@@ -0,0 +1,57 @@
+### 栈和队列
+
+#### 简介
+
+栈的特点是后入先出，根据这个特点可以临时保存一些数据，之后用到依次再弹出来，常用于 DFS 深度搜索
+
+队列一般常用于 BFS 广度搜索，类似一层一层的搜索。
+
+#### Stack 栈
+
+##### 155.最小栈 [min-stack](https://leetcode-cn.com/problems/min-stack/)
+
+> 设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。
+
+思路：用两个栈实现，一个最小栈始终保证最小值在顶部
+
+```js
+/**
+ * initialize your data structure here.
+ */
+var MinStack = function() {
+    this.stack = []; // JS用数组表示栈
+    this.minStack = [Infinity];
+};
+
+/** 
+ * @param {number} x
+ * @return {void}
+ */
+MinStack.prototype.push = function(x) {
+    this.stack.push(x);
+    this.minStack.push(Math.min(this.minStack[this.minStack.length-1],x));
+};
+
+/**
+ * @return {void}
+ */
+MinStack.prototype.pop = function() {
+    this.stack.pop();
+    this.minStack.pop();
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.top = function() {
+    return this.stack[this.stack.length-1];
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.getMin = function() {
+    return this.minStack[this.minStack.length-1];
+};
+```
+

数据结构篇/链表.md

@@ -13,7 +13,7 @@
 
 #### 练习
 
-83. 删除排序链表中的重复元素 [remove-duplicates-from-sorted-list](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/)
+##### 83.删除排序链表中的重复元素 [remove-duplicates-from-sorted-list](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/)
 
 > 给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
 
@@ -43,7 +43,7 @@ var deleteDuplicates = function(head) {
 };
 ```
 
-82.删除排序链表中的重复元素Ⅱ（删除重复数字的节点，只保留没有重复数字的节点）[remove-duplicates-from-sorted-list-ii](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/)
+##### 82.删除排序链表中的重复元素Ⅱ（删除重复数字的节点，只保留没有重复数字的节点）[remove-duplicates-from-sorted-list-ii](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/)
 
 > 给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中  没有重复出现的数字。
 
@@ -72,7 +72,7 @@ var deleteDuplicates = function(head) {
 };
 ```
 
-206.反转一个单链表（头插法）。[reverse-linked-list](https://leetcode-cn.com/problems/reverse-linked-list/)
+##### 206.反转一个单链表（头插法）。[reverse-linked-list](https://leetcode-cn.com/problems/reverse-linked-list/)
 
 > 输入: 1->2->3->4->5->NULL
 > 输出: 5->4->3->2->1->NULL
@@ -91,7 +91,7 @@ var reverseList = function(head) {
 };
 ```
 
-92. 反转链表Ⅱ [reverse-linked-list-ii](https://leetcode-cn.com/problems/reverse-linked-list-ii/)
+##### 92.反转链表Ⅱ [reverse-linked-list-ii](https://leetcode-cn.com/problems/reverse-linked-list-ii/)
 
 反转从位置 *m* 到 *n* 的链表。请使用一趟扫描完成反转。**说明:**1 ≤ *m* ≤ *n* ≤ 链表长度。
 
@@ -117,7 +117,9 @@ var reverseBetween = function(head, m, n) {
 };
 ```
 
-21.合并两个有序链表 [merge-two-sorted-lists](https://leetcode-cn.com/problems/merge-two-sorted-lists/)，将两个升序链表合并为一个新的 **升序** 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 
+##### 21.合并两个有序链表 
+
+将两个升序链表合并为一个新的 **升序** 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 
 
 > 输入：1->2->4, 1->3->4
 > 输出：1->1->2->3->4->4
@@ -159,7 +161,7 @@ var mergeTwoLists = function(l1, l2) {
 };
 ```
 
-86.分隔链表 [分隔链表](https://leetcode-cn.com/problems/partition-list/) 
+##### 86.分隔链表 [分隔链表](https://leetcode-cn.com/problems/partition-list/) 
 
 给定一个链表和一个特定值 *x*，对链表进行分隔，使得所有小于 *x* 的节点都在大于或等于 *x* 的节点之前。你应当保留两个分区中每个节点的初始相对位置。