非递归实现树的先序/中序/后序遍历

先序遍历

利用根在访问次序两端这一特性

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

通用做法

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

中序遍历

通用做法

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

后序遍历

通用做法：加入计数器

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> postOrder;
        if(root==nullptr) return postOrder;
        stack<TreeNode*> s;
        map<TreeNode*,int> vis;
        TreeNode* u=root;
        while(!s.empty()||u!=nullptr){
            if(u!=nullptr){
                s.push(u);
                vis[u]=1;
                u=u->left;
            }
            else{
                u=s.top();
                if(vis[u]==1){
                    ++vis[u];
                    u=u->right;
                }
                else{
                    s.pop();
                    postOrder.push_back(u->val);
                    u=nullptr;
                }
            }
        }
        return postOrder;
    }
};

利用根在访问次序两端这一特性：双栈

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> postOrder;
        if(root==nullptr) return postOrder;
        stack<TreeNode*> s1,s2;
        s1.push(root);
        while(!s1.empty()){
            TreeNode* u=s1.top();s1.pop();
            s2.push(u);
            if(u->left!=nullptr)
                s1.push(u->left); 
            if(u->right!=nullptr)
                s1.push(u->right);
        }
        while(!s2.empty()){
            TreeNode* u=s2.top();s2.pop();
            postOrder.push_back(u->val);
        }
        return postOrder;
    }
};