二叉树的前中后序遍历(递归&非递归)

中序递归：

class Solution {
public:
    vector<int> res;
    vector<int> inorderTraversal(TreeNode * root) {
        inorder(root);
        return res;
    }
    void inorder(TreeNode * root){
        if (root!=NULL){
           inorder(root->left);
           res.push_back(root->val);
           inorder(root->right); 
        }
    }
};

中序非递归(使用栈)：

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

后序非递归：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if (root==NULL) return res;
        stack<TreeNode*> s;
        TreeNode* this_node=root;
        TreeNode* rec;
        while (!s.empty()||this_node)
        {
            if (this_node)
            {
                s.push(this_node);
                this_node=this_node->left;
            }
            else 
            {//需要判断这棵树刚刚访问的是左子树还是右子树
               this_node=s.top();
               //如果有右子树且右子树还没访问，就访问右子树
               if (this_node->right&&this_node->right!=rec)
               {
                   this_node=this_node->right;
                   s.push(this_node);
                   this_node=this_node->left;
               }
               //否则说明这棵树已经访问完了，弹出并向上回溯
               else
               {
                  res.push_back(this_node->val);
                  rec=this_node;
                  this_node=NULL;
                  s.pop();
               }
            }        
        }
        return res;
    }
};

前序非递归:

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