Merge branch 'master' of https://github.com/azl397985856/leetcode

lucifer · lucifer · commit 00d7613f39bb · 2020-06-29T16:01:57.000+08:00
diff --git a/problems/102.binary-tree-level-order-traversal.md b/problems/102.binary-tree-level-order-traversal.md
@@ -202,3 +202,7 @@ class Solution:
 ## 相关题目
 - [103.binary-tree-zigzag-level-order-traversal](./103.binary-tree-zigzag-level-order-traversal.md)
 - [104.maximum-depth-of-binary-tree](./104.maximum-depth-of-binary-tree.md)
+
+## 相关专题
+
+- [二叉树的遍历](https://github.com/azl397985856/leetcode/blob/master/thinkings/binary-tree-traversal.md)
diff --git a/problems/144.binary-tree-preorder-traversal.md b/problems/144.binary-tree-preorder-traversal.md
@@ -33,7 +33,11 @@ Follow up: Recursive solution is trivial, could you do it iteratively?
 前序遍历是`根左右`的顺序，注意是`根`开始，那么就很简单。直接先将根节点入栈，然后
 看有没有右节点，有则入栈，再看有没有左节点，有则入栈。 然后出栈一个元素，重复即可。
 
-> 其他树的非递归遍历课没这么简单
+> 其他树的非递归遍历可没这么简单
+
+![](https://tva1.sinaimg.cn/large/007S8ZIlly1gg7v5hztd2j30zu0ntwiu.jpg)
+
+（迭代 VS 递归）
 
 ## 关键点解析
 
@@ -58,44 +62,6 @@ Follow up: Recursive solution is trivial, could you do it iteratively?
 JavaScript Code:
 
 ```js
-/*
- * @lc app=leetcode id=144 lang=javascript
- *
- * [144] Binary Tree Preorder Traversal
- *
- * https://leetcode.com/problems/binary-tree-preorder-traversal/description/
- *
- * algorithms
- * Medium (50.36%)
- * Total Accepted:    314K
- * Total Submissions: 621.2K
- * Testcase Example:  '[1,null,2,3]'
- *
- * Given a binary tree, return the preorder traversal of its nodes' values.
- *
- * Example:
- *
- *
- * Input: [1,null,2,3]
- * ⁠  1
- * ⁠   \
- * ⁠    2
- * ⁠   /
- * ⁠  3
- *
- * Output: [1,2,3]
- *
- *
- * Follow up: Recursive solution is trivial, could you do it iteratively?
- *
- */
-/**
- * Definition for a binary tree node.
- * function TreeNode(val) {
- *     this.val = val;
- *     this.left = this.right = null;
- * }
- */
 /**
  * @param {TreeNode} root
  * @return {number[]}
@@ -115,13 +81,13 @@ var preorderTraversal = function(root) {
   let t = stack.pop();
 
   while (t) {
-    ret.push(t.val);
     if (t.right) {
       stack.push(t.right);
     }
     if (t.left) {
       stack.push(t.left);
     }
+    ret.push(t.val);
     t = stack.pop();
   }
 
@@ -159,3 +125,7 @@ public:
     }
 };
 ```
+
+## 相关专题
+
+- [二叉树的遍历](https://github.com/azl397985856/leetcode/blob/master/thinkings/binary-tree-traversal.md)
diff --git a/problems/145.binary-tree-postorder-traversal.md b/problems/145.binary-tree-postorder-traversal.md
@@ -59,37 +59,6 @@ mid是一个具体的节点，left和right`递归求出即可`
 ## 代码
 
 ```js
-/*
- * @lc app=leetcode id=145 lang=javascript
- *
- * [145] Binary Tree Postorder Traversal
- *
- * https://leetcode.com/problems/binary-tree-postorder-traversal/description/
- *
- * algorithms
- * Hard (47.06%)
- * Total Accepted:    242.6K
- * Total Submissions: 512.8K
- * Testcase Example:  '[1,null,2,3]'
- *
- * Given a binary tree, return the postorder traversal of its nodes' values.
- *
- * Example:
- *
- *
- * Input: [1,null,2,3]
- * ⁠  1
- * ⁠   \
- * ⁠    2
- * ⁠   /
- * ⁠  3
- *
- * Output: [3,2,1]
- *
- *
- * Follow up: Recursive solution is trivial, could you do it iteratively?
- *
- */
 /**
  * Definition for a binary tree node.
  * function TreeNode(val) {
@@ -138,3 +107,9 @@ var postorderTraversal = function(root) {
 };
 
 ```
+
+## 相关专题
+
+- [二叉树的遍历](https://github.com/azl397985856/leetcode/blob/master/thinkings/binary-tree-traversal.md)
+
+
diff --git a/problems/167.two-sum-ii-input-array-is-sorted.md b/problems/167.two-sum-ii-input-array-is-sorted.md
@@ -92,3 +92,14 @@ class Solution:
             if numbers[left] + numbers[right] == target:
                 return [left+1, right+1]
 ```
+
+**复杂度分析**
+- 时间复杂度：$O(N)$
+- 空间复杂度：$O(1)$
+
+更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode  。 目前已经30K star啦。
+
+关注公众号力扣加加，努力用清晰直白的语言还原解题思路，并且有大量图解，手把手教你识别套路，高效刷题。
+
+
+![](https://tva1.sinaimg.cn/large/007S8ZIlly1gfcuzagjalj30p00dwabs.jpg)
diff --git a/problems/26.remove-duplicates-from-sorted-array.md b/problems/26.remove-duplicates-from-sorted-array.md
@@ -60,6 +60,8 @@ for (int i = 0; i < len; i++) {
 
 （图片来自： https://github.com/MisterBooo/LeetCodeAnimation)
 
+> 实际上这就是双指针中的快慢指针。在这里快指针是读指针， 慢指针是写指针。
+
 ## 关键点解析
 
 - 双指针
@@ -130,3 +132,14 @@ public:
     }
 };
 ```
+
+**复杂度分析**
+- 时间复杂度：$O(N)$
+- 空间复杂度：$O(1)$
+
+更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode  。 目前已经30K star啦。
+
+关注公众号力扣加加，努力用清晰直白的语言还原解题思路，并且有大量图解，手把手教你识别套路，高效刷题。
+
+
+![](https://tva1.sinaimg.cn/large/007S8ZIlly1gfcuzagjalj30p00dwabs.jpg)
diff --git a/problems/94.binary-tree-inorder-traversal.md b/problems/94.binary-tree-inorder-traversal.md
@@ -66,43 +66,6 @@ Follow up: Recursive solution is trivial, could you do it iteratively?
 JavaScript Code：
 
 ```js
-/*
- * @lc app=leetcode id=94 lang=javascript
- *
- * [94] Binary Tree Inorder Traversal
- *
- * https://leetcode.com/problems/binary-tree-inorder-traversal/description/
- *
- * algorithms
- * Medium (55.22%)
- * Total Accepted:    422.4K
- * Total Submissions: 762.1K
- * Testcase Example:  '[1,null,2,3]'
- *
- * Given a binary tree, return the inorder traversal of its nodes' values.
- *
- * Example:
- *
- *
- * Input: [1,null,2,3]
- * ⁠  1
- * ⁠   \
- * ⁠    2
- * ⁠   /
- * ⁠  3
- *
- * Output: [1,3,2]
- *
- * Follow up: Recursive solution is trivial, could you do it iteratively?
- *
- */
-/**
- * Definition for a binary tree node.
- * function TreeNode(val) {
- *     this.val = val;
- *     this.left = this.right = null;
- * }
- */
 /**
  * @param {TreeNode} root
  * @return {number[]}
@@ -277,3 +240,7 @@ class Solution {
     }
 }
 ```
+
+## 相关专题
+
+- [二叉树的遍历](https://github.com/azl397985856/leetcode/blob/master/thinkings/binary-tree-traversal.md)
diff --git a/thinkings/binary-tree-traversal.md b/thinkings/binary-tree-traversal.md
@@ -2,8 +2,7 @@
 
 ## 概述
 
-二叉树作为一个基础的数据结构，遍历算法作为一个基础的算法，两者结合当然是经典的组合了。
-很多题目都会有 ta 的身影，有直接问二叉树的遍历的，有间接问的。
+二叉树作为一个基础的数据结构，遍历算法作为一个基础的算法，两者结合当然是经典的组合了。很多题目都会有 ta 的身影，有直接问二叉树的遍历的，有间接问的。比如要你找到树中满足条件的节点，就是间接考察树的遍历，因为你要找到树中满足条件的点，就需要进行遍历。
 
 > 你如果掌握了二叉树的遍历，那么也许其他复杂的树对于你来说也并不遥远了
 
@@ -139,8 +138,12 @@ class Solution:
         return res
 ```
 
+可以看出，实现上 WHITE 就表示的是递归中的第一次进入过程，Gray 则表示递归中的从叶子节点返回的过程。 因此这种迭代的写法更接近递归写法的本质。
+
 如要实现前序、后序遍历，只需要调整左右子节点的入栈顺序即可。可以看出使用三色标记法， 其写法类似递归的形式，因此便于记忆和书写，缺点是使用了额外的内存空间。不过这个额外的空间是线性的，影响倒是不大。
 
+> 虽然递归也是额外的线性时间，但是递归的栈开销还是比一个 0，1 变量开销大的。
+
 ## Morris 遍历
 
 我们可以使用一种叫做 Morris 遍历的方法，既不使用递归也不借助于栈。从而在$O(1)$时间完成这个过程。
@@ -184,3 +187,15 @@ def MorrisTraversal(root):
 ```
 
 参考： [what-is-morris-traversal](https://www.educative.io/edpresso/what-is-morris-traversal)
+
+## 相关题目
+
+- [lowest-common-ancestor-of-a-binary-tree](https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/)
+- [binary-tree-level-order-traversal](https://leetcode-cn.com/problems/binary-tree-level-order-traversal/)
+- [binary-tree-zigzag-level-order-traversal](https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/)
+- [validate-binary-search-tree](https://leetcode-cn.com/problems/validate-binary-search-tree/)
+- [maximum-depth-of-binary-tree](https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/)
+- [balanced-binary-tree](https://leetcode-cn.com/problems/balanced-binary-tree/)
+- [binary-tree-level-order-traversal-ii](https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii/)
+- [binary-tree-maximum-path-sum](https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/)
+- [insert-into-a-binary-search-tree](https://leetcode-cn.com/problems/insert-into-a-binary-search-tree/)
diff --git a/thinkings/bit.md b/thinkings/bit.md
@@ -190,8 +190,13 @@ class Solution:
 - 空间复杂度：$O(1)$
 
 
-更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode  。 目前已经接近30K star啦。
+## 相关题目
 
-大家也可以关注我的公众号《脑洞前端》获取更多更新鲜的LeetCode题解
+- [number-of-1-bits](https://leetcode-cn.com/problems/number-of-1-bits/)
+- [counting-bits](https://leetcode-cn.com/problems/counting-bits/)
+- [reverse-bits](https://leetcode-cn.com/problems/reverse-bits/)
 
-![](https://pic.leetcode-cn.com/89ef69abbf02a2957838499a96ce3fbb26830aae52e3ab90392e328c2670cddc-file_1581478989502)
+
+更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode  。 目前已经30K star啦。
+
+关注公众号力扣加加，努力用清晰直白的语言还原解题思路，并且有大量图解，手把手教你识别套路，高效刷题。
diff --git a/thinkings/dynamic-programming.md b/thinkings/dynamic-programming.md
@@ -184,7 +184,7 @@ f(n) = f(n-1) + f(n-2) 就是【状态转移公式】
 
 ## 总结
 
-本篇文章总结了算法中比较常用的两个方法 - 递归和动态规划。
+本篇文章总结了算法中比较常用的两个方法 - 递归和动态规划。递归的话可以拿树的题目练手，动态规划的话则将我上面推荐的刷完，再考虑去刷力扣的动态规划标签即可。
 
 如果你只能记住一句话，那么请记住：`递归是从问题的结果倒推，直到问题的规模缩小到寻常。 动态规划是从寻常入手， 逐步扩大规模到最优子结构。`
 
diff --git a/thinkings/slide-window.md b/thinkings/slide-window.md
@@ -79,7 +79,7 @@ class Solution:
         return  0 if ans == len(nums) + 1 else ans
 ```
 
-## 题目列表
+## 题目列表（有题解）
 
 以下题目有的信息比较直接，有的题目信息比较隐蔽，需要自己发掘
 
@@ -94,6 +94,7 @@ class Solution:
 - [【1234. 替换子串得到平衡字符串】[Java/C++/Python] Sliding Window](https://leetcode.com/problems/replace-the-substring-for-balanced-string/discuss/408978/javacpython-sliding-window/367697)
 - [【1248. 统计「优美子数组」】滑动窗口（Python）](https://leetcode-cn.com/problems/count-number-of-nice-subarrays/solution/1248-tong-ji-you-mei-zi-shu-zu-hua-dong-chuang-kou/)
 
+
 ## 扩展阅读
 
 - [LeetCode Sliding Window Series Discussion](https://leetcode.com/problems/binary-subarrays-with-sum/discuss/186683/)
