feat: 更新电子书地址&整理

Author: suukii

.gitignore

@@ -1 +1 @@
-*.suukii.*
+**.local.**

README.md

@@ -39,6 +39,8 @@
       - [贪心拓展题目](#贪心拓展题目)
   - [其他](#其他)
 
+> [在线电子书](https://app.gitbook.com/@suki/s/91-days-algorithm/)
+>
 > [DSA 讲义 - private repo](https://github.com/leetcode-pp/91alg-2#%E8%AE%B2%E4%B9%89)
 >
 > [参考题解 - private repo](https://github.com/leetcode-pp/91alg-2#%E9%A2%98%E8%A7%A3)
@@ -115,6 +117,8 @@
 
 -   [x] [105.从前序与中序遍历序列构造二叉树](./basic/binary-tree/ext-construct-binary-tree-from-preorder-and-inorder-traversal.md)
 -   [x] [404.左叶子之和](./basic/binary-tree/ext-sum-of-left-leaves.md)
+-   [x] [257.二叉树的所有路径](./basic/binary-tree/ext-binary-tree-paths.md)
+-   [x] [112.路径总和](./basic/binary-tree/ext-path-sum.md)
 
 ### 哈希表
 
@@ -133,7 +137,7 @@
 -   [x] [645.错误的集合](./basic/hashmap/ext-set-mismatch.md)
 -   [x] [面试题 04.01.节点间通路](./basic/hashmap/ext-route-between-nodes-lcci.md)
 -   [ ] [36.有效的数独](https://leetcode-cn.com/problems/valid-sudoku)
--   [ ] [149.直线上最多的点数](/)
+-   [ ] [149.直线上最多的点数](https://leetcode-cn.com/problems/max-points-on-a-line)
 
 ### 双指针
 
@@ -148,10 +152,11 @@
 
 #### 双指针拓展题目
 
--   [x] [875.爱吃香蕉的珂珂](./basic/day-26.md)
--   [x] [167.两数之和 II - 输入有序数组](./basic/day-28.md)
--   [x] [42.接雨水](./basic/day-29.md)
--   [x] [面试题 17.11.单词距离](./basic/day-30.md)
+-   [x] [875.爱吃香蕉的珂珂](./basic/two-pointers/ext-koko-eating-bananas.md)
+-   [x] [167.两数之和 II - 输入有序数组](./basic/two-pointers/ext-two-sum-ii-input-array-is-sorted.md)
+-   [x] [42.接雨水](./basic/two-pointers/ext-trapping-rain-water.md)
+-   [x] [面试题 17.11.单词距离](./basic/two-pointers/ext-find-closest-lcci.md)
+-   [ ] [11.盛最多水的容器](https://leetcode-cn.com/problems/container-with-most-water)
 
 ## 进阶篇
 
@@ -265,6 +270,4 @@
 ## 其他
 
 -   [x] [77.组合](./extensions/77.combination.md)
--   [x] [112.路径总和](./extensions/112.path-sum.md)
--   [x] [257.二叉树的所有路径](./extensions/257.binary-tree-paths.md)
 -   [ ] [面试题 04.09. 二叉搜索树序列](./extensions/04.09.bst-sequences-lcci.md)

extensions/257.binary-tree-paths.md …sic/binary-tree/ext-binary-tree-paths.mdextensions/257.binary-tree-paths.md renamed to basic/binary-tree/ext-binary-tree-paths.md extensions/257.binary-tree-paths.md renamed to basic/binary-tree/ext-binary-tree-paths.md

@@ -2,6 +2,13 @@
 
 https://leetcode-cn.com/problems/binary-tree-paths/
 
+- [257.二叉树的所有路径](#257二叉树的所有路径)
+  - [题目描述](#题目描述)
+  - [方法 1：DFS](#方法-1dfs)
+    - [思路](#思路)
+    - [复杂度](#复杂度)
+    - [代码](#代码)
+
 ## 题目描述
 
 ```
@@ -28,7 +35,9 @@ https://leetcode-cn.com/problems/binary-tree-paths/
 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 ```
 
-## 思路
+## 方法 1：DFS
+
+### 思路
 
 **DFS**
 
@@ -42,11 +51,11 @@ https://leetcode-cn.com/problems/binary-tree-paths/
   5
 ```
 
--   想象有一个小精灵拿着篮子站在了根节点 `1`，它把 `1` 放进了篮子里，接着，它的面前出现了两条路 `2` 和 `3`。
+-   想象一下，有一个小精灵拿着篮子站在了根节点 `1`，它把 `1` 放进了篮子里，接着，它的面前出现了两条路 `2` 和 `3`。
 -   小精灵使用影分身复制了一个自己和一个篮子，一个分身往左走，一个分身往右走。
--   往左走的小精灵继续把 `2` 放进篮子，然后再往右下走把 `5` 放进篮子，这时候篮子是 `[1,2,4]`，由于在 `5` 没法继续前进了，这个篮子就被保存起来了。
+-   往左走的小精灵继续把 `2` 放进篮子，然后再往右下走把 `5` 放进篮子，这时候篮子是 `[1,2,5]`，由于在 `5` 没法继续前进了，这个篮子就被保存起来了。
 -   再回来看一开始往右走的小精灵，它往右下走到 `3`，把 `3` 装进篮子，这时候篮子是 `[1,3]`，由于没有路了，这个篮子也被保存了起来。
--   小精灵最终得到了两个篮子 `[1,2,4]` 和 `[1,3]`。
+-   小精灵最终得到了两个篮子 `[1,2,5]` 和 `[1,3]`。
 
 **回溯**
 
@@ -55,16 +64,16 @@ https://leetcode-cn.com/problems/binary-tree-paths/
 -   小精灵拿着篮子从 `1` 开始，此时篮子是 `[1]`，
 -   接着它先往左走，走到 `2`，篮子是 `[1,2]`，
 -   从 `2` 再往右走，走到 `5`，篮子是 `[1,2,5]`，到这里已经不能继续前进了，小精灵就把篮子里的东西复制一份保存起来，然后转身往回走，
--   一边走一边把篮子里的东西往外人，从 `5` 走回 `2`，此时篮子是 `[1,2]`，把 `5` 扔掉了，
+-   一边走一边把篮子里的东西往外扔，从 `5` 走回 `2`，此时篮子是 `[1,2]`，把 `5` 扔掉了，
 -   从 `2` 开始也没有其他还没走过的路了，所以回退到 `1`，此时篮子只剩 `[1]`。
 -   到了 `1` 这个位置，小精灵发现右边的路还没走，于是就往右边去捡东西了，这个过程跟之前往左走是一样的。
 
-## 复杂度
+### 复杂度
 
 -   时间复杂度：$O(n)$，n 为二叉树的节点数。
 -   空间复杂度：$O(h)$，h 为二叉树的高度。
 
-## 代码
+### 代码
 
 JavaScript Code
 
@@ -84,17 +93,21 @@ var binaryTreePaths = function (root) {
     if (!root) return [];
 
     const ans = [];
-    const dfs = (node, path) => {
+    dfs(root, []);
+    return ans;
+
+    // *******************************
+    function dfs(node, path) {
         if (!node) return;
+
         if (!node.left && !node.right) {
             ans.push([...path, node.val].join('->'));
             return;
         }
+
         dfs(node.left, [...path, node.val]);
         dfs(node.right, [...path, node.val]);
-    };
-    dfs(root, []);
-    return ans;
+    }
 };
 ```
 
@@ -117,21 +130,26 @@ var binaryTreePaths = function (root) {
 
     const ans = [];
     const path = [];
-    const dfs = node => {
+    dfs(root);
+    return ans;
+
+    // ******************************
+    function dfs(node) {
         if (!node) return;
+
         path.push(node.val);
 
         if (!node.left && !node.right) {
             ans.push(path.join('->'));
+            // 回溯
             path.pop();
             return;
         }
 
         dfs(node.left);
         dfs(node.right);
+        // 回溯
         path.pop();
-    };
-    dfs(root);
-    return ans;
+    }
 };
 ```

extensions/112.path-sum.md basic/binary-tree/ext-path-sum.mdextensions/112.path-sum.md renamed to basic/binary-tree/ext-path-sum.md

@@ -2,6 +2,17 @@
 
 https://leetcode-cn.com/problems/path-sum/
 
+- [112.路径总和](#112路径总和)
+  - [题目描述](#题目描述)
+  - [方法 1：递归](#方法-1递归)
+    - [思路](#思路)
+    - [复杂度分析](#复杂度分析)
+    - [代码](#代码)
+  - [迭代+队列](#迭代队列)
+    - [思路](#思路-1)
+    - [复杂度分析](#复杂度分析-1)
+    - [代码](#代码-1)
+
 ## 题目描述
 
 ```
@@ -26,7 +37,7 @@ https://leetcode-cn.com/problems/path-sum/
 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 ```
 
-## 递归
+## 方法 1：递归
 
 ### 思路
 
@@ -76,12 +87,12 @@ TypeScript Code
  */
 
 function hasPathSum(root: TreeNode | null, sum: number): boolean {
-    if (!root) return false
-    if (!root.left && !root.right) return root.val === sum
+    if (!root) return false;
+    if (!root.left && !root.right) return root.val === sum;
     return (
         hasPathSum(root.left, sum - root.val) ||
         hasPathSum(root.right, sum - root.val)
-    )
+    );
 }
 ```
 
@@ -116,33 +127,33 @@ TypeScript Code
  */
 
 function hasPathSum(root: TreeNode | null, sum: number): boolean {
-    if (!root) return false
+    if (!root) return false;
 
-    const queue: TreeNode[] = [root]
-    const sums: number[] = [root.val]
+    const queue: TreeNode[] = [root];
+    const sums: number[] = [root.val];
 
     while (true) {
-        let len: number = queue.length
-        if (len === 0) break
+        let len: number = queue.length;
+        if (len === 0) break;
         while (len > 0) {
-            len--
-            const node: TreeNode = queue.shift() as TreeNode
-            const temp: number = sums.shift() as number
+            len--;
+            const node: TreeNode = queue.shift() as TreeNode;
+            const temp: number = sums.shift() as number;
 
             if (!node.left && !node.right) {
-                if (temp === sum) return true
-                continue
+                if (temp === sum) return true;
+                continue;
             }
             if (node.left) {
-                queue.push(node.left)
-                sums.push(node.left.val + temp)
+                queue.push(node.left);
+                sums.push(node.left.val + temp);
             }
             if (node.right) {
-                queue.push(node.right)
-                sums.push(node.right.val + temp)
+                queue.push(node.right);
+                sums.push(node.right.val + temp);
             }
         }
     }
-    return false
+    return false;
 }
 ```