update: 二叉树遍历系列

Author: suukii

README.md

@@ -162,13 +162,13 @@
 
 ### 高频面试题
 
+-   [x] [【day-34】二叉树遍历系列](./medium/hot/34.traversal-of-binary-tree.md)
 -   [x] [【day-34】581.最短无序连续子数组](./medium/day-34.md)
 -   [x] [【day-35】78.子集](./medium/day-35.md)
 -   [x] [【day-36】62.不同路径](./medium/day-36.md)
 -   [x] [【day-37】有效括号系列](./medium/day-37.md)
 -   [x] [【day-38】反转链表系列](./medium/day-38.md)
 -   [x] [【day-39】前缀和系列](./medium/day-39.md)
--   [x] [【day-40】二叉树遍历系列](./medium/day-40.md)
 
 ### 前缀树
 

medium/day-40.md medium/hot/34.traversal-of-binary-tree.mdmedium/day-40.md renamed to medium/hot/34.traversal-of-binary-tree.md

@@ -10,8 +10,8 @@
 
 **扩展**
 
-- 多叉树的遍历，参考[图的遍历](https://github.com/suukii/Articles/blob/master/articles/dsa_graph.md)
-- O(1)空间的遍历，[Morris Traversal](https://github.com/suukii/Articles/blob/master/articles/dsa_binary_tree.md#morris-traversal)
+-   多叉树的遍历，参考[图的遍历](https://github.com/suukii/Articles/blob/master/articles/dsa/dsa_graph.md#%E5%9B%BE%E7%9A%84%E9%81%8D%E5%8E%86)
+-   $O(1)$ 空间的遍历，[Morris Traversal](https://github.com/suukii/Articles/blob/master/articles/dsa/dsa_binary_tree.md#morris-traversal)
 
 # 144.二叉树的前序遍历
 
@@ -33,8 +33,8 @@ preorder(root.right)
 
 ### 复杂度分析
 
-- 时间复杂度：O(2^h)，h 为二叉树的高度。也可以表示为 O(n)，n 为二叉树的节点数。
-- 空间复杂度：O(h)，h 为二叉树的高度。
+-   时间复杂度：$O(2^h)$，h 为二叉树的高度。也可以表示为 $O(n)$，n 为二叉树的节点数。
+-   空间复杂度：$O(h)$，h 为二叉树的高度。
 
 ### 代码
 
@@ -53,13 +53,13 @@ JavaScript Code
  * @return {number[]}
  */
 var preorderTraversal = function (root, res = []) {
-  if (!root) return []
+    if (!root) return [];
 
-  res.push(root.val)
-  root.left && preorderTraversal(root.left, res)
-  root.right && preorderTraversal(root.right, res)
-  return res
-}
+    res.push(root.val);
+    root.left && preorderTraversal(root.left, res);
+    root.right && preorderTraversal(root.right, res);
+    return res;
+};
 ```
 
 ## 迭代
@@ -87,18 +87,18 @@ JavaScript Code
  * @return {number[]}
  */
 var preorderTraversal = function (root) {
-  const stack = [root]
-  const res = []
-
-  while (stack.length > 0) {
-    const node = stack.pop()
-    if (node) {
-      res.push(node.val)
-      stack.push(node.right, node.left)
+    const stack = [root];
+    const res = [];
+
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node) {
+            res.push(node.val);
+            stack.push(node.right, node.left);
+        }
     }
-  }
-  return res
-}
+    return res;
+};
 ```
 
 # 94.二叉树的中序遍历
@@ -136,12 +136,12 @@ JavaScript Code
  * @return {number[]}
  */
 var inorderTraversal = function (root, res = []) {
-  if (!root) return []
-  root.left && inorderTraversal(root.left, res)
-  res.push(root.val)
-  root.right && inorderTraversal(root.right, res)
-  return res
-}
+    if (!root) return [];
+    root.left && inorderTraversal(root.left, res);
+    res.push(root.val);
+    root.right && inorderTraversal(root.right, res);
+    return res;
+};
 ```
 
 ## 迭代
@@ -170,20 +170,20 @@ JavaScript Code
  * @return {number[]}
  */
 var inorderTraversal = function (root) {
-  const stack = []
-  const res = []
-
-  while (root || stack.length > 0) {
-    while (root) {
-      stack.push(root)
-      root = root.left
+    const stack = [];
+    const res = [];
+
+    while (root || stack.length > 0) {
+        while (root) {
+            stack.push(root);
+            root = root.left;
+        }
+        root = stack.pop();
+        res.push(root.val);
+        root = root.right;
     }
-    root = stack.pop()
-    res.push(root.val)
-    root = root.right
-  }
-  return res
-}
+    return res;
+};
 ```
 
 # 145.二叉树的后序遍历
@@ -221,24 +221,28 @@ JavaScript Code
  * @return {number[]}
  */
 var postorderTraversal = function (root, res = []) {
-  if (!root) return []
-  root.left && postorderTraversal(root.left, res)
-  root.right && postorderTraversal(root.right, res)
-  res.push(root.val)
-  return res
-}
+    if (!root) return [];
+
+    root.left && postorderTraversal(root.left, res);
+    root.right && postorderTraversal(root.right, res);
+    res.push(root.val);
+
+    return res;
+};
 ```
 
 ## 迭代
 
-### 思路
+### 思路 1
+
+这是比较讨巧的思路。
 
 1. 二叉树的前序遍历是 root -> left -> right
 2. 二叉树的后序遍历是 left -> right -> root
 3. 可以看到后序遍历差不多是前序遍历的结果倒转过来，我们可以把前序遍历的套路拿过来稍做改动。
 4. 只需把第 2 步把 node 存入 res 这一步由 `res.push(node.val)` 改为 `res.unshift(node.val)`，并且将左右子节点入栈的顺序调换一下即可。
 
-### 代码
+### 代码 1
 
 JavaScript Code
 
@@ -255,17 +259,79 @@ JavaScript Code
  * @return {number[]}
  */
 var postorderTraversal = function (root) {
-  const stack = [root]
-  const res = []
-  while (stack.length > 0) {
-    const node = stack.pop()
-    if (node) {
-      stack.push(node.left, node.right)
-      res.unshift(node.val)
+    const stack = [root];
+    const res = [];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node) {
+            stack.push(node.left, node.right);
+            res.unshift(node.val);
+        }
     }
-  }
-  return res
-}
+    return res;
+};
+```
+
+### 思路 2
+
+这是比较正经的思路。
+
+因为后序遍历的顺序是 left -> right -> root，我们需要先遍历 left，但如果直接遍历，访问完 left 之后没办法回到 root 了，因为二叉树的子节点是没有指向父节点的指针的。
+
+所以，在遍历 left 之前，我们需要把 root 和 right 存起来，访问完 left 之后再回到 root，这时候需要判断，如果 root.right 存在且还没访问过，就先去访问 root.right，否则直接打印 root 的值。
+
+1. 将 root.right 和 root 入栈，稍后遍历。
+2. 让 `root = root.left` (相当于将 root 看成一个 cur 指针)。
+3. 当 root 不为空时，重复步骤 1 和 2。
+4. 开始出栈，`root = stack.pop()`，检查 root.right 有没有被访问过：
+    1. 如果没有被访问过的话，这时候 root.right 应该在栈顶，将 root.right 弹出，然后将 root 压回栈等最后再遍历。接着让 `root = root.right`，开始处理右子树。
+    2. 如果已经被访问过，或者 root.right 为空的话，这时我们直接打印 root 的值就好了。
+
+### 代码 2
+
+JavaScript Code
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var postorderTraversal = function (root) {
+    if (!root) return [];
+
+    const stack = [];
+    const res = [];
+
+    while (true) {
+        while (root) {
+            root.right && stack.push(root.right);
+            stack.push(root);
+            root = root.left;
+        }
+
+        root = stack.pop();
+
+        if (root.right && root.right === stack[stack.length - 1]) {
+            const right = stack.pop();
+            stack.push(root);
+            root = right;
+        } else {
+            res.push(root.val);
+            root = null;
+        }
+
+        if (!stack.length) break;
+    }
+
+    return res;
+};
 ```
 
 # 102.二叉树的层序遍历
@@ -288,8 +354,8 @@ var postorderTraversal = function (root) {
 
 ### 复杂度分析
 
-- 时间复杂度：O(n)，n 为树的节点数。
-- 空间复杂度：O(2^h)，h 为树的高度，队列的最大长度是最深一层叶子节点的总数 2^(h-1)。
+-   时间复杂度：$O(n)$，n 为树的节点数。
+-   空间复杂度：$O(2^h)$，h 为树的高度，队列的最大长度是最深一层叶子节点的总数 $2^(h-1)$。
 
 ### 代码
 
@@ -309,27 +375,27 @@ JavaScript Code
  * @return {number[][]}
  */
 var levelOrder = function (root) {
-  if (!root) return []
-
-  const result = []
-  const queue = [root, null]
-  let level = 0
-
-  while (queue.length > 0) {
-    const node = queue.shift()
-
-    if (node) {
-      result[level] || (result[level] = [])
-      result[level].push(node.val)
-      node.left && queue.push(node.left)
-      node.right && queue.push(node.right)
-    } else {
-      queue.length > 0 && queue.push(null)
-      level++
+    if (!root) return [];
+
+    const result = [];
+    const queue = [root, null];
+    let level = 0;
+
+    while (queue.length > 0) {
+        const node = queue.shift();
+
+        if (node) {
+            result[level] || (result[level] = []);
+            result[level].push(node.val);
+            node.left && queue.push(node.left);
+            node.right && queue.push(node.right);
+        } else {
+            queue.length > 0 && queue.push(null);
+            level++;
+        }
     }
-  }
-  return result
-}
+    return result;
+};
 ```
 
 Python Code
@@ -356,12 +422,15 @@ class Solution(object):
     while len(queue) > 0:
       size = len(queue)
       level = []
+
       for i in range(size):
         node = queue.pop(0)
+
         if node != None:
           level.append(node.val)
           if node.left != None: queue.append(node.left)
           if node.right != None: queue.append(node.right)
+
       items.append(level)
     return items
 ```
@@ -374,8 +443,8 @@ class Solution(object):
 
 ### 复杂度分析
 
-- 时间复杂度：O(n), n 为二叉树的节点数。
-- 空间复杂度：O(n), n 为二叉树的节点数，`res` 数组的空间是 O(n)，调用栈的空间最大是 O(h)，h 是二叉树的深度，因为 n >= h，所以最后还是 O(n)。
+-   时间复杂度：$O(n)$, n 为二叉树的节点数。
+-   空间复杂度：$O(n)$, n 为二叉树的节点数，`res` 数组的空间是 $O(n)$，调用栈的空间最大是 $O(h)$，h 是二叉树的深度，因为 $n >= h$，所以最后还是 $O(n)$。
 
 ### 代码
 
@@ -394,12 +463,14 @@ JavaScript Code
  * @return {number[][]}
  */
 var levelOrder = function (root, depth = 0, res = []) {
-  if (!root) return []
-
-  res[depth] || (res[depth] = [])
-  res[depth].push(root.val)
-  levelOrder(root.left, depth + 1, res)
-  levelOrder(root.right, depth + 1, res)
-  return res
-}
+    if (!root) return [];
+
+    res[depth] || (res[depth] = []);
+    res[depth].push(root.val);
+
+    levelOrder(root.left, depth + 1, res);
+    levelOrder(root.right, depth + 1, res);
+
+    return res;
+};
 ```