LeetCode - 二叉树前序中序后序遍历的非递归写法

二叉树先序中序后序遍历的非递归写法

相关的题目：

144. 二叉树的前序遍历

94. 二叉树的中序遍历

145. 二叉树的后序遍历

思想：用栈来模仿递归

1. 前序

前序：访问根节点后，先将右子树根节点压栈，然后再将左子树根节点压栈，因为先序遍历是先访问根节点再访问左子树后访问右子树，因此为了在出栈时先左子树先于右子树访问，压栈时需要先压栈右子树，再压栈左子树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if (!root) return {};
        vector<int> res;
        stack<TreeNode*> st{{root}};
        while (!st.empty()) {
            TreeNode *t = st.top(); st.pop();
            res.push_back(t->val);
            if (t->right) st.push(t->right);
            if (t->left) st.push(t->left);
        }
        return res;
    }
};

2. 中序

中序遍历是先左子树再根节点，最后右子树，这里附设一个指针指向当前遍历的节点，因为在遍历根节点之前需要将左子树所有节点遍历完毕，因此需要一个while循环遍历完所有左子树节点，将其全部压栈，然后在遍历根节点，最后将访问指针切到到右子树节点。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if (!root) return {};
        stack<TreeNode*> st;
        TreeNode *p = root;
        vector<int> res;
        while (p || !st.empty()) {
            while (p) {
                st.push(p);
                p = p->left;
            }
            p = st.top(); st.pop();
            res.push_back(p->val);
            p = p->right;
        }
        return res;
    }
};

3. 后序

后序遍历会比较麻烦一点，但是一个投机取巧的方法是，将后序遍历转为前序遍历，后序遍历：左->右->根，前序遍历是：根->左->右，因此我们把前序遍历逆序一下，右->左->根，即可将前序遍历的程序做少量微调即可解决后序迭代遍历问题。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if (!root) return {};
        vector<int> res;
        stack<TreeNode*> st{{root}};
        while (!st.empty()) {
            TreeNode *t = st.top(); st.pop();
            res.push_back(t->val);
            if (t->left) st.push(t->left);
            if (t->right) st.push(t->right);
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

总结

二叉树的前、中、后序遍历的时间复杂度均为$O(N)$，因为所有节点都遍历一遍，空间复杂度为$O(log(H))$，H为树的高度。