update 手写

Author: lirunkai

docs/_media/容器盛水.png

@@ -17,7 +17,9 @@ new干了什么？
 
 原型链
 
-原型链是主要的继承方式。
+原型链是主要的继承方式。原型链指的是实例在继承父类时, 实例的原型是父类的实例
+
+`实例.__proto__= 原形.prototype`
 
 主要思想就是原型是另一个类型的实例。也就是这个原型本身有一个内部指针(`__proto__`)指向另一个原型, 相应的另一个原型也有一个指针指向另一个构造函数。这样就在实例和原形之间构造了一条原型链
 

docs/base/js.md

@@ -32,12 +32,9 @@ this 值
 谁调用的函数， this 指向就是谁
 
 ```javascript
-Function.prototype.call2 = function () {
-  let [thisArg, ...args] = [...arguments];
-  thisArg = Object(thisArg) || window;
-  let fn = Symbol();
+Function.prototype.call2 = function (thisArg, ...args) {
   thisArg[fn] = this;
-  let result = thisArg[fn](...args);
+  const result = thisArg[fn](...args)
   delete thisArg[fn];
   return result;
 };
@@ -48,10 +45,7 @@ Function.prototype.call2 = function () {
 apply 传入的是一个数组
 
 ```javascript
-Function.prototype.apply2 = function (thisArg = window) {
-  let [thisArg, args] = [...args];
-  thisArg = Object(thisArg);
-  let fn = Symbol();
+Function.prototype.apply2 = function (thisArg, args) {
   thisArg[fn] = this;
   let result = thisArg[fn](...args);
   delete thisArg.fn;
@@ -64,22 +58,6 @@ Function.prototype.apply2 = function (thisArg = window) {
 和 call 相比多了处理`prototype`的部分，返回的是一个函数
 
 ```javascript
-Function.prototype.bind2 = function (content) {
-  if (typeof this !== "function") {
-    throw Error("not a function");
-  }
-  let fn = this;
-  let args = [...arguments].slice(1);
-
-  let resFn = function () {
-    return fn.apply(this instanceof resFn ? this : content, args);
-  };
-  function tmp() {}
-  tmp.prototype = this.prototype;
-  resFn.prototype = new tmp();
-  return resFn;
-};
-
 Function.prototype.myBind = function (context, ...args) {
   return (...newArgs) => {
     return this.call(context, ...args, ...newArgs);

docs/js/手写.md

@@ -8,6 +8,11 @@
 
 给定一个整数数组 `nums` ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
 
+思路:
+
+1. 如果累加值大于0, 则继续加
+2. 如果累加值小于0, 则重置值
+
 ```
 输入: [-2,1,-3,4,-1,2,1,-5,4]
 输出: 6
@@ -67,3 +72,37 @@ function climbStairs(n) {
 }
 ```
 
+4. #### [最长递增子序列](https://leetcode-cn.com/problems/longest-increasing-subsequence/)
+
+给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。
+
+子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。
+
+```
+输入：nums = [10,9,2,5,3,7,101,18]
+输出：4
+解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。
+```
+
+思路：	
+
+不会
+
+```javascript
+function lengthOfLIS(nums) {
+  let n = nums.length
+  if(n == 0) return 0
+  let dep = new Array(n).fill(1)
+  let max = 0
+  for(let i = 0; i < n; i++) {
+    for(let j = 0; j < i; j++) {
+      if(nums[j] < nums[i]) {
+        dp[i] = Math.max(dp[i], dp[j]+1)
+      }
+    }
+    max = Math.max(max. dp[i])
+  }
+  return max
+}
+```
+

docs/算法/动态规划.md

@@ -101,3 +101,164 @@ function hasCycle(head) {
 }
 ```
 
+4. #### [盛最多水的容器](https://leetcode-cn.com/problems/container-with-most-water/)
+
+思路：
+
+乘最多的水, 也就是面积要最大, 那么就是要最长最高
+
+为什么双指针的做法是正确的？
+
+双指针代表了什么？
+
+双指针代表的是 可以作为容器边界的所有位置的范围。在一开始，双指针指向数组的左右边界，表示 数组中所有的位置都可以作为容器的边界，因为我们还没有进行过任何尝试。在这之后，我们每次将 对应的数字较小的那个指针 往 另一个指针 的方向移动一个位置，就表示我们认为 这个指针不可能再作为容器的边界了。
+
+```javascript
+function maxArea(height) {
+  let left = 0
+  let right = height - 1
+  let ans = 0
+  while(left < right) {
+    let area = Math.min(height(left), height[right]) * (right - left)
+    ans = Math.max(ans, area)
+    
+    if(height[left] < height[right]) {
+      left++
+    } else {
+      right--
+    }
+  }
+  return ans
+}
+```
+
+4. #### [最接近的三数之和](https://leetcode-cn.com/problems/3sum-closest/)
+
+```javascript
+function threeSumClosest(nums, target) {
+  	nums.sort((a, b) => a - b);
+	  let res = nums[0] + nums[1] + nums[nums.length - 1];
+  	 for (let i = 0; i < nums.length - 2; i++) {
+      const n1 = nums[i];
+      let l = i + 1;
+      let r = nums.length - 1;
+      while (l < r) {
+        const n2 = nums[l];
+        const n3 = nums[r];
+        const sum = n1 + n2 + n3;
+        if (sum > target) {
+          r--;
+        } else {
+          l++;
+        }
+        if (Math.abs(sum - target) < Math.abs(res - target)) {
+          res = sum;
+        }
+      }
+    }
+    return res;
+}
+```
+
+5. #### [三数之和](https://leetcode-cn.com/problems/3sum/)
+
+   ```javascript
+   var threeSum = function(nums) {
+       let ans = []
+       let len = nums.length
+       if(nums == null || len < 3) return ans
+       nums.sort((a,b) => a-b)
+       for(let i = 0; i < len; i++) {
+           if(nums[i] > 0) break;
+           if(i > 0 && nums[i] == nums[i-1]) continue
+           let L = i + 1
+           let R = len - 1
+           while(L < R) {
+               let sum = nums[i] + nums[L] +nums[R]
+               if(sum == 0) {
+                   ans.push([nums[i], nums[L], nums[R]])
+                   while(L<R && nums[L] == nums[L+1]) L++
+                   while(L<R && nums[R] == nums[R-1]) R--
+                   L++
+                   R--
+               } else if(sum > 0) {
+                   R--
+               } else {
+                   L++
+               }
+           }
+       }
+       return ans
+   };
+   ```
+
+   
+
+6. #### [旋转链表](https://leetcode-cn.com/problems/rotate-list/)
+
+```javascript
+function rotateRight(head, k) {
+ 	let fast = head, slow = head
+  while(k--) {
+    if(fast && fast.next) fast = fast.next
+    else fast = head // 循环了一圈回来了
+  }
+  
+  if(slow == fast) return head
+  while(fast.next) {
+    slow = slow.next
+    fast = fast.next
+  }
+  
+  fast.next = head
+  head = slow.next
+  slow.next = null
+  return head
+}
+```
+
+7. #### [最长不含重复字符的子字符串](https://leetcode-cn.com/problems/zui-chang-bu-han-zhong-fu-zi-fu-de-zi-zi-fu-chuan-lcof/)
+
+```javascript
+function lengthOfLongestSubstring(s) {
+  let start = 0, end = 0
+    let res = 0
+    const map = new Map()
+    while(end < s.length) {
+        if(map.get(s[end]) >= start) {
+            start = map.get(s[end]) + 1
+            map.set(s[end], end)
+        } else {
+            map.set(s[end], end)
+            res = Math.max(res, end - start + 1)
+        }
+        end++
+    }
+    return res
+}
+```
+
+8. 容器盛水问题
+
+   给定一个整形数组arr，已知其中所有的值都是非负的，将这个数组看作一个容器，请返回容器能装多少水。
+
+   ![](../_media/容器盛水.png)
+
+```javascript
+function maxWater(arr) {
+  let left = 0, right = arr.length - 1
+  let leftMax = 0, rightMax = 0
+  let sum = 0
+  while(left < right) {
+    leftMax = Math.max(leftMax, arr[left])
+    rightMax = Math.max(rightMax, arr[right])
+    if(leftMax <= rightMax) {
+      sum += leftMax - arr[left++]
+    } else {
+      sum += rightMax - arr[right--]
+    }
+  }
+  return sum
+}
+```
+

docs/算法/双指针.md

@@ -1,3 +1,12 @@
+回朔法
+
+采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用最简单的递归方法来实现，在反复重复上述的步骤后可能出现两种情况
+
+- 找到一个可能存在的正确的答案；
+- 在尝试了所有可能的分步方法后宣告该问题没有答案
+
+练习：
+
 1. #### [子集](https://leetcode-cn.com/problems/subsets/)
 
 给你一个整数数组 `nums` ，返回该数组所有可能的子集（幂集）。解集不能包含重复的子集。
@@ -34,3 +43,102 @@ const subsets = (nums) => {
 };
 ```
 
+2. #### [全排列](https://leetcode-cn.com/problems/permutations/)
+
+给定一个 **没有重复** 数字的序列，返回其所有可能的全排列。
+
+```
+输入: [1,2,3]
+输出:
+[
+  [1,2,3],
+  [1,3,2],
+  [2,1,3],
+  [2,3,1],
+  [3,1,2],
+  [3,2,1]
+]
+```
+
+思路：
+
+怎么写递归函数
+
++ 我们要在这个包含解的空间树上，用 DFS（递归）的方式搜索出所有的解。
+
++ dfs 函数做的事：基于当前的 path，继续选数，直到构建出合法的path，加入解集。
+  + 递归的入口：dfs 执行传入空 path，什么都还没选。
+
+  + 函数体内，用 for 循环，枚举出当前所有的选项，并通过 if 语句跳过剪枝项。
+
+    + 每一轮迭代，作出一个选择，基于它，继续选（递归调用）。
+
+      递归的出口：当构建的 path 数组长度等于 nums 长度，就选够了，加入解集。
+
+为什么要回溯
+
++ 我们不是找到一个排列就完事，要找出所有满足条件的排列。
+
++ 递归结束时，结束的是当前的递归分支，还要去别的分支继续搜。
+
++ 所以，要撤销当前的选择，回到选择前的状态，去选下一个选项，即切入下一个分支。
+
++ 退回来，把路走全，才能在一棵空间树中，回溯出所有的解。
+
+```javascript
+function permute(nums) {
+  	let res = []
+    let used = {}
+    function deps(path) {
+      if(path.length == nums.length) {
+        res.push(path.slice())
+        return
+      }
+      for(let num of nums) {
+        if(used[num]) continue
+        path.push(num)
+        used[num] = true
+        deps(path)
+        path.pop()
+        used[num] = false
+      }
+    }
+  	deps([])
+  	return res
+}
+```
+
+3. 加起来和为目标值的组合
+
+给出一组候选数和一个目标数, 找出候选数中 和为目标数的所有组合
+
+```
+input: [100, 10, 20, 70, 60, 10, 50] 80
+output: [[10,10,60],[10,20,50],[10,70],[20,60]]
+```
+
+解
+
+```javascript
+function combinationSum2(nums, target) {
+  let result = []
+  nums.sort((a,b) => a-b)
+  function combination(arr, start, val) {
+    if(val == 0) {
+      result.push([...arr])
+    } else {
+      for(let i = start; i < nums.length; i++) {
+        if(nums[i] <= val && (i== start || nums[i] != nums[i - 1]) {
+         		val -= nums[i]
+        		arr.push(nums[i])
+        		combination(arr, i, val)
+        		arr.pop()
+        		val += nums[i]
+         }
+      }
+    }
+  }
+  combination([], 0, target)
+}
+```
+