力扣 -- 144. 二叉树的前、中、后序遍历(迭代算法)

1. 题目

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

2. 示例

(1)前序

如果用二叉树的非递归做这道题：

（1）把一棵树拆成两个部分去访问：左路节点，左路节点上的右子树

前序遍历就是根~左子树~根~左子树，左路节点访问完了，还剩左路节点上的右子树。

（2）访问左路节点时，同时入栈左路节点

（3）访问右子树时，先弹出左路节点，再访问它的右子树，不断拆解成子问题，用循环来做：

        1的左子树访问完了要访问1的右子树，1的右子树为空，还有3和5的右子树没访问，1作为3的左子树，3的左子树访问完了，要访问3的右子树，4和6访问完之后，要访问5的右树，7的左子树为空，访问完了就访问7的右子树8，8的左右子树都为空，结束。

 完整过程如下：

 

 

 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        vector<int> v; 

        // 1、节点为空但栈还有节点需要访问右子树
        // 2、节点不为空但栈已经没有节点
        while (cur || !st.empty())
        {
            // 开始访问一棵树
            // 1、左路节点
            // 2、左路节点的右子树
            while (cur)
            {
                v.push_back(cur->val);
                st.push(cur);
                cur = cur->left;
            }

            // 开始访问右子树
            TreeNode* top = st.top();
            st.pop();
            // 子问题访问右子树
            cur = top->right;
        }
        return v;
    }
};

---

(2)中序

1.左子树访问完毕后，才能访问根

2.左树节点先不访问，不为空时就入栈

3.和二叉树的前序遍历不一样的地方在于，入数组的时机不一样：

       （1） 前序是入栈时就入数组

       （2）中序是出栈时就入数组

 

 

 

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        vector<int> v;

        while (cur || !st.empty())
        {
            // 1、左路节点
            while (cur)
            {
                st.push(cur);
                cur = cur->left;
            }

            // 栈里面取到左路节点，左路节点的左子树访问完了
            TreeNode* top = st.top();
            st.pop();
            v.push_back(top->val);

            // 访问左路节点右子树 -- 子问题
            cur = top->right;
        }
        return v;
    }
};

---

（3）后序

1.左右子树都访问完毕后，才能访问根

2.如何知道一个节点的左右子树都访问完了呢？用指针记录上一个访问的节点，如果上一个访问的节点恰好是节点的右子树的根，那么说明左右子树都已经访问完了，现在就可以访问节点了

 

 

 

 

 

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        vector<int> v;

        TreeNode* prev = nullptr;
        while (cur || !st.empty())
        {
            // 左路节点
            while (cur)
            {
                st.push(cur);
                cur = cur->left;
            }

            // 栈里面取到左路节点，左路节点左子树已经访问完了
            TreeNode* top = st.top();

            // 1、右为空 或者 右子树已经访问过了(上一个访问的节点是右子树的根)， 可以访问根节点
            if (top->right == nullptr || top->right == prev)
            {
                v.push_back(top->val);
                st.pop();
                prev = top;
            }
            else
            {
                cur = top->right;
            }
        }
        return v;
    }
};