Merge pull request #2808 from gazeldx/set_iteration_binary_tree

二叉树的统一迭代法.md 加入"boolean标记法"和相关C++、Python代码实现

problems/二叉树的统一迭代法.md

@@ -27,11 +27,16 @@
 
 **那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。**
 
-如何标记呢，**就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。** 这种方法也可以叫做标记法。
+如何标记呢？
+
+* 方法一：**就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。** 这种方法可以叫做`空指针标记法`。
+
+* 方法二：**加一个 `boolean` 值跟随每个节点，`false` (默认值) 表示需要为该节点和它的左右儿子安排在栈中的位次，`true` 表示该节点的位次之前已经安排过了，可以收割节点了。** 
+这种方法可以叫做`boolean 标记法`，样例代码见下文`C++ 和 Python 的 boolean 标记法`。 这种方法更容易理解，在面试中更容易写出来。
 
 ### 迭代法中序遍历
 
-中序遍历代码如下：（详细注释）
+> 中序遍历（空指针标记法）代码如下：（详细注释）
 
 ```CPP
 class Solution {
@@ -70,6 +75,45 @@ public:
 
 可以看出我们将访问的节点直接加入到栈中，但如果是处理的节点则后面放入一个空节点， 这样只有空节点弹出的时候，才将下一个节点放进结果集。
 
+> 中序遍历（boolean 标记法）：
+```c++
+class Solution {
+public:
+    vector<int> inorderTraversal(TreeNode* root) {
+        vector<int> result;
+        stack<pair<TreeNode*, bool>> st;
+        if (root != nullptr)
+            st.push(make_pair(root, false)); // 多加一个参数，false 为默认值，含义见下文注释
+
+        while (!st.empty()) {
+            auto node = st.top().first;
+            auto visited = st.top().second; //多加一个 visited 参数，使“迭代统一写法”成为一件简单的事
+            st.pop();
+
+            if (visited) { // visited 为 True，表示该节点和两个儿子位次之前已经安排过了，现在可以收割节点了
+                result.push_back(node->val);
+                continue;
+            }
+
+            // visited 当前为 false, 表示初次访问本节点，此次访问的目的是“把自己和两个儿子在栈中安排好位次”。
+            
+            // 中序遍历是'左中右'，右儿子最先入栈，最后出栈。
+            if (node->right)
+                st.push(make_pair(node->right, false));
+            
+            // 把自己加回到栈中，位置居中。
+            // 同时，设置 visited 为 true，表示下次再访问本节点时，允许收割。
+            st.push(make_pair(node, true));
+
+            if (node->left)
+                st.push(make_pair(node->left, false)); // 左儿子最后入栈，最先出栈
+        }
+        
+        return result;
+    }
+};
+```
+
 此时我们再来看前序遍历代码。
 
 ### 迭代法前序遍历
@@ -105,7 +149,7 @@ public:
 
 ### 迭代法后序遍历
 
-后续遍历代码如下： (**注意此时我们和中序遍历相比仅仅改变了两行代码的顺序**)
+> 后续遍历代码如下： (**注意此时我们和中序遍历相比仅仅改变了两行代码的顺序**)
 
 ```CPP
 class Solution {
@@ -136,6 +180,42 @@ public:
 };
 ```
 
+> 迭代法后序遍历（boolean 标记法）：
+```c++
+class Solution {
+public:
+    vector<int> postorderTraversal(TreeNode* root) {
+        vector<int> result;
+        stack<pair<TreeNode*, bool>> st;
+        if (root != nullptr)
+            st.push(make_pair(root, false)); // 多加一个参数，false 为默认值，含义见下文
+
+        while (!st.empty()) {
+            auto node = st.top().first;
+            auto visited = st.top().second; //多加一个 visited 参数，使“迭代统一写法”成为一件简单的事
+            st.pop();
+
+            if (visited) { // visited 为 True，表示该节点和两个儿子位次之前已经安排过了，现在可以收割节点了
+                result.push_back(node->val);
+                continue;
+            }
+
+            // visited 当前为 false, 表示初次访问本节点，此次访问的目的是“把自己和两个儿子在栈中安排好位次”。
+            // 后序遍历是'左右中'，节点自己最先入栈，最后出栈。
+            // 同时，设置 visited 为 true，表示下次再访问本节点时，允许收割。
+            st.push(make_pair(node, true));
+
+            if (node->right)
+                st.push(make_pair(node->right, false)); // 右儿子位置居中
+
+            if (node->left)
+                st.push(make_pair(node->left, false)); // 左儿子最后入栈，最先出栈
+        }
+        
+        return result;
+    }
+};
+```
 ## 总结
 
 此时我们写出了统一风格的迭代法，不用在纠结于前序写出来了，中序写不出来的情况了。
@@ -234,7 +314,7 @@ class Solution {
 
 ### Python：
 
-迭代法前序遍历：
+> 迭代法前序遍历（空指针标记法）：
 ```python
 class Solution:
     def preorderTraversal(self, root: TreeNode) -> List[int]:
@@ -257,7 +337,7 @@ class Solution:
         return result
 ```
 
-迭代法中序遍历：
+> 迭代法中序遍历（空指针标记法）：
 ```python
 class Solution:
     def inorderTraversal(self, root: TreeNode) -> List[int]:
@@ -282,7 +362,7 @@ class Solution:
         return result
 ```
 
-迭代法后序遍历：
+> 迭代法后序遍历（空指针标记法）：
 ```python
 class Solution:
     def postorderTraversal(self, root: TreeNode) -> List[int]:
@@ -306,6 +386,61 @@ class Solution:
         return result
 ```
 
+> 中序遍历，统一迭代（boolean 标记法）：
+```python
+class Solution:
+    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        values = []
+        stack = [(root, False)] if root else [] # 多加一个参数，False 为默认值，含义见下文
+
+        while stack:
+            node, visited = stack.pop() # 多加一个 visited 参数，使“迭代统一写法”成为一件简单的事
+            
+            if visited: # visited 为 True，表示该节点和两个儿子的位次之前已经安排过了，现在可以收割节点了
+                values.append(node.val)
+                continue
+
+            # visited 当前为 False, 表示初次访问本节点，此次访问的目的是“把自己和两个儿子在栈中安排好位次”。
+            # 中序遍历是'左中右'，右儿子最先入栈，最后出栈。
+            if node.right:
+                stack.append((node.right, False))
+
+            stack.append((node, True)) # 把自己加回到栈中，位置居中。同时，设置 visited 为 True，表示下次再访问本节点时，允许收割
+
+            if node.left:
+                stack.append((node.left, False)) # 左儿子最后入栈，最先出栈
+
+        return values
+```
+
+> 后序遍历，统一迭代（boolean 标记法）：
+```python
+class Solution:
+    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        values = []
+        stack = [(root, False)] if root else [] # 多加一个参数，False 为默认值，含义见下文
+
+        while stack:
+            node, visited = stack.pop() # 多加一个 visited 参数，使“迭代统一写法”成为一件简单的事
+
+            if visited: # visited 为 True，表示该节点和两个儿子位次之前已经安排过了，现在可以收割节点了
+                values.append(node.val)
+                continue
+
+            # visited 当前为 False, 表示初次访问本节点，此次访问的目的是“把自己和两个儿子在栈中安排好位次”
+            # 后序遍历是'左右中'，节点自己最先入栈，最后出栈。
+            # 同时，设置 visited 为 True，表示下次再访问本节点时，允许收割。
+            stack.append((node, True))
+
+            if node.right:
+                stack.append((node.right, False)) # 右儿子位置居中
+
+            if node.left:
+                stack.append((node.left, False)) # 左儿子最后入栈，最先出栈
+        
+        return values
+```
+
 ### Go：
 
 > 前序遍历统一迭代法