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

递归解法很简单，构建一个辅助函数helper，改变一下其中的两行代码的顺序便可实现前序中序后序遍历，代码如下：

前序遍历（递归）

 vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(!root)   return res;
        helper(root,res);
        return res;
    }
    void helper(TreeNode* root,vector<int>& res)
    {
        if(!root)   return;
        res.push_back(root->val);
        helper(root->left,res);
        helper(root->right,res);
    }

中序遍历（递归）

     vector<int> inorderTraversal(TreeNode* root) {
            vector<int> res;
            if(!root)   return res;
            helper(root,res);
            return res;
        }
        void helper(TreeNode* root,vector<int>& res)
        {
            if(!root)   return;
            helper(root->left,res);
            res.push_back(root->val);
            helper(root->right,res);
        }

后序遍历（递归）

     vector<int> lastorderTraversal(TreeNode* root) {
            vector<int> res;
            if(!root)   return res;
            helper(root,res);
            return res;
        }
        void helper(TreeNode* root,vector<int>& res)
        {
            if(!root)   return;
            helper(root->left,res);
            helper(root->right,res);
            res.push_back(root->val);
        }

非递归解法核心在与栈的运用

前序遍历（非递归）

 vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==NULL) return res;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()){
            auto node=st.top();
            res.push_back(node->val);
            st.pop();
            if(node->right!=NULL) st.push(node->right);
            if(node->left!=NULL) st.push(node->left);
        }
        return res;
    }

中序遍历（非递归）

vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        while(true)
        {
            if(root){
                st.push(root);
                root = root->left;
            }else{
                if(st.empty())
                    return res;
                root = st.top();
                res.push_back(root->val);
                st.pop();
                root = root->right;
            }
        }    
    }

后序遍历（非递归）

 vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==NULL) return res;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()){
            root=st.top();
            st.pop();
            res.push_back(root->val);
            if(root->left) st.push(root->left);
            if(root->right) st.push(root->right);
        }
        reverse(res.begin(),res.end());
        return res;
    }