二叉树的前序遍历、中序遍历、后序遍历迭代实现

遍历树有DFS和BFS两种方法，而DFS又因为输出节点的先后顺序分为了3种，采用递归来实现前、中、后序遍历非常简单，本文记录一下这3种遍历的迭代实现。
要点：树的前、中、后序遍历迭代实现要借助栈这个数据结构。
以下面这棵树为例：

前序遍历

leetcode第144题：https://leetcode-cn.com/problems/binary-tree-preorder-traversal/
前序遍历就是当访问到一个节点时，先输出该节点内容，再分别去访问其左右子节点。
例子的遍历结果为：[1,4,2,3,7,8,6,9]

我们先将根节点压栈，当栈不为空时执行以下操作：

• 输出栈顶节点top并弹出栈
• 若top右子节点不为空，将右子节点压栈
• 若top左子节点不为空，将左子节点压栈

考虑到栈后进先出的特点，我们自然要按右-左的顺序压栈。

代码

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if (!root) return {};
        vector<int> result;
        stack<TreeNode*> s;
        s.push(root);
        while (!s.empty()) {
            TreeNode* top = s.top();
            result.push_back(top->val);
            s.pop();
            if (top->right) s.push(top->right);
            if (top->left) s.push(top->left);
        }
        return result;
    }
};

后续遍历

leetcode第145题：https://leetcode-cn.com/problems/binary-tree-postorder-traversal/
后续遍历就是当访问到一个节点时，先分别去访问其左右子节点，再输出该节点内容。
例子的遍历结果为：[4,7,8,3,9,6,2,1]

我们先将根节点压栈，当栈不为空时执行以下操作：

• 对于栈顶元素，如果其右子节点不为空且尚未被输出过，将右子节点压栈
• 对其左子节点同样进行上一操作
• 如果前两种情况都未导致压栈，则输出这个栈顶元素并弹出栈，记录其已被输出

自然地，要记录是否被输出过，就得用到哈希表

代码

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        unordered_set<TreeNode*> set;
        stack<TreeNode*> s;
        if (root) s.push(root);
        while (!s.empty()) {
            TreeNode* top = s.top();
            bool flag1 = true, flag2 = true;
            if (top->right && set.find(top->right) == set.end()) {
                s.push(top->right);
                flag1 = false;
            }
            if (top->left && set.find(top->left) == set.end()) {
                s.push(top->left);
                flag2 = false;
            }
            if (flag1 && flag2) {
                result.push_back(top->val);
                set.insert(top);
                s.pop();
            }
        }
        return result;
    }
};

中序遍历

leetcode第94题：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
中序遍历就是当访问到一个节点时，先去访问其左子节点，再输出该节点，最后再访问其右节点。
例子的遍历结果为：[4,1,7,3,8,2,9,6]

使用哈希表

我们先将根节点压栈，当栈不为空时执行以下操作：

• 对于栈顶元素，如果其左子节点不为空且尚未被输出过，将左子节点压栈
• 如果不满足上一情况，输出栈顶元素并弹出栈，记录其已被输出过。如果其右子节点不为空，将右子节点压栈

对于右子节点不需要判断其是否被输出过，因为对于一个节点，其左子节点会在它之前被输出，其右子节点是在它之后被输出的。在输出完左子节点后再次访问到该节点，这时其右子节点肯定尚未被输出过。
后续遍历中节点的左右子节点都是在它之前被输出，所以都要进行判断。

代码

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> s;
        unordered_set<TreeNode*> set;
        if (root) s.push(root);
        while (!s.empty()) {
            TreeNode* top = s.top();
            if (top->left && set.find(top->left) == set.end()) s.push(top->left);
            else {
                result.push_back(top->val);
                set.insert(top);
                s.pop();
                if (top->right) s.push(top->right);
            }
        }
        return result;
    }
};

不使用哈希表

不使用哈希表的写法与递归实现的思路类似，用一个指针一直向左遍历，并将遍历过程中的节点压栈。输出完左子节点后，弹出栈，此时栈顶为其父节点，输出并弹出栈，再将指针指向其右子节点，继续遍历。

代码

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> s;
        while (root || !s.empty()) {
            while (root){
                s.push(root);
                root = root->left;
            }
            root = s.top();
            s.pop();
            result.push_back(root->val);
            root = root->right;
        }
        return result;
    }
};