二叉树的前中后序非递归法

Posted 2021-07-25 Y—X

题目集合：
144. 二叉树的前序遍历

94. 二叉树的中序遍历

145. 二叉树的后序遍历

前序遍历：
思路：前序非递归遍历需要借助栈

1. 如果树为空，直接返回
2. 如果树非空：从根节点位置开始遍历，因为前序遍历规则：根节点、左子树、右子树
   a. 沿着根节点一直往左走，将所经过路径中的节点依次入栈，并访问。
   b. 取栈顶元素，该元素取到后，其左子树要么为空，要么已经遍历，可以直接遍历该节点，对于该节点，其左子树已经遍历，该节点也已经遍历，剩余其右子树没有遍历，将其左子树当成一棵新的树开始遍历，继续a

/**
 * 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) {
        vector<int> v;
        stack<TreeNode*> st;

        TreeNode* cur = root;

        while(cur || !st.empty())
        {
            //1.访问并保存左路节点进栈
            while(cur)
            {
                v.push_back(cur->val);
                st.push(cur);
                cur = cur->left;
            }

            //2.对于root这棵树，剩下的时左路节点的右子树没有访问
            //依次从栈里拿出来
            TreeNode* node = st.top();
            st.pop();

            //子问题走右子树
            cur = node->right;
        }

        return v;
    }
};

中序遍历：思路类似

/**
 * 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> inorderTraversal(TreeNode* root) {
        vector<int> v;
        stack<TreeNode*> st;

        TreeNode* cur = root;
        while(cur || !st.empty())
        {
            while(cur)
            {
                st.push(cur);
                cur = cur->left;
            }

            TreeNode* top = st.top();
            st.pop();

            v.push_back(top->val);
            // 将pCur的右子树当成一棵二叉树来遍历
            cur = top->right;
        }

        return v;
    }
};

后序遍历：
思路：

1. 空树，直接返回
2. 如果树非空：从根节点位置开始遍历，但此时根节点不能遍历，因为后序遍历规则：左子树、右子树、根节点
   a. 沿着根节点一直往左走，将所经过路径中的节点依次入栈
   b. 取栈顶元素，该元素取到后，其左子树要么为空，要么已经遍历，
   但是此时该节点不能遍历，除非其右子树不存在或者其右子树已经遍历，才可以遍历该节点
   如果该节点右子树没有遍历，将其右子树作为一棵新的二叉树遍历，继续a

/**
 * 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> postorderTraversal(TreeNode* root) {
        vector<int> v;
        stack<TreeNode*> st;

        TreeNode* prev = nullptr;
        TreeNode* cur = root;

        while(cur || !st.empty())
        {
            while(cur)
            {
                st.push(cur);
                cur = cur->left;
            }

            TreeNode* node = st.top();
            //如果右为空，或者有孩子等于访问的上一个节点，那么说明右树访问过了
            if(node->right == nullptr || node->right == prev)
            {
                v.push_back(node->val);
                st.pop();
                prev = node;
                cur == nullptr;
            }
            else
            {
                cur = node->right;
            }
        }

        return v;
    }
};