迭代法遍历二叉树

二叉树遍历（迭代版）

二叉树的遍历主要分为四种，前序遍历，中序遍历，后序遍历和层序遍历。之前写过递归版，本次主要将前三种的遍历的迭代版本。迭代版本需要自己写一个栈来实现数据的存取。具体如下：

前序迭代法

首先自己创建一个栈，栈是后进先出的线性表，所以每次只能将栈顶元素弹出，根据前序遍历的规则，如果根节点不为空，将根节点入栈，弹出，然后遍历根节点的左子树，入栈，弹出，然后遍历根节点的右子树。

/**
 * 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;
        vector<int> v;
        while(root != nullptr || !st.empty())
        {
            while(root != nullptr)
            {
                v.push_back(root->val);
                st.push(root);
                root = root->left;//访问根节点的左节点，根节点还没有弹出
            }
            root = st.top();
            st.pop();
            root = root->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) {
        stack<TreeNode*> st;
        vector<int> v;
        while(root != nullptr || !st.empty())
        {
            while(root != nullptr)
            {
                st.push(root);
                root = root->left;
            }
            root = st.top();
            st.pop();
            v.push_back(root->val);
            root = root->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> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> v;
        while(root != nullptr || !st.empty())
        {
            while(root != nullptr)
            {
                v.push_back(root->val);
                st.push(root);
                root = root->right;
            }
            root = st.top();
            st.pop();
            root = root->left;
        }
        reverse(v.begin(), v.end());
        return v;
    }
};