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

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/musechipin/article/details/84107660

中序递归：

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){
            stack<TreeNode *> s;
            TreeNode * this_node=root;
            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;
    }
};