树的遍历——迭代法

不适用递归而使用栈来实现树的前序，中序，后序遍历。

假设我们要遍历一刻二叉树，结果放进result中。

栈具有反转顺序的特点，假如最简单一棵二叉树A，两个儿子B、C， 正的顺序是A B C， 那么入栈顺序肯定是C B A。所以根据倒序特点：（右边是入栈顺序）

• 前序遍历：中 左 右 ——> 右 左 中
• 中序遍历：左 中 右 ——> 右 中 左
• 后续遍历： 左 右 中——> 中 右 左

递归来说，虽然访问顺序不同，但是递归的过程是一样的，都是由上到下这样，只不过访问根节点（放入当前节点到result）的时机不同。

当我们用栈，栈中pop出节点r 表示处理以r为根的树(箭头第一次到r)，但不代表要放它进result，只有前序可以，对于中序，要让left的元素在root上方，right的元素在下面；而对于后序，则要left, right的结果都在上面。也就是说root需要再次入栈，然后等待子节点把自己的处理结果放在root的上面。那么这个再次入栈，我们如何辨别它不等同于第一次 (处理以r为根的树)？

我们采用标记方法：第二次 r入栈后面放NULL来标记，这样出栈的时候只要判断遇到NULL就将后一个节点放入result即可。

也就是说，二次放入root没有别的意思，仅仅只是记录值，因为暂时没法放进result 而已，所以存在栈中，等到左边结果都出栈后它才会出栈。

中序遍历

//中序遍历：右 中 左
vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop(); // 将该节点弹出, 处理node子树
                if (node->right) st.push(node->right);  // 添加右节点（空节点不入栈）

                st.push(node);                          // 二次添加中节点
                st.push(NULL); 

                if (node->left) st.push(node->left);    // 添加左节点（空节点不入栈）
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           
                node = st.top();    
                st.pop();
                result.push_back(node->val); 
            }
        }
        return result;
    }

后续遍历

同理后序遍历，其实就是root存在栈中，等待左边和右边的结果入栈出栈。就把刚刚的入栈顺序变一下，root的二次入栈放在右左之后即可。

while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左
                st.push(node);                          // 中
                st.push(NULL);
            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }

前序遍历

最简单，不需要二次入栈了，相当于第一次遍历到就可以直接进结果了，因为root最先出栈进result，不需要等待左右结果

vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();                      // 中
            st.pop();
            if (node != NULL) result.push_back(node->val);
            else continue;
            st.push(node->right);                           // 右
            st.push(node->left);                            // 左
        }
        return result;
    }

总结：

stack中存了什么：

1）等待被遍历的子树 r（没有NULL跟着）

2）已经遍历过，等待放入result的r (有NULL跟着，NULL覆盖在它的上一层）