树的前，中，后 序遍历

前序遍历：

非递归：

   vector<int> inorderTraversal(TreeNode *root) {
        if(root==NULL)
            return vector<int>();
        stack<TreeNode*> trees;
        while(!trees.empty()||root){
            while(root){
                result.push_back(root->val);
                trees.push(root);
                root=root->left;
            }
            if(!trees.empty()){
                root=trees.top();
                trees.pop();
                root=root->right;
            }
        }
        return result;
    }

递归：

    vector<int> inorderTraversal(TreeNode *root) {
        if(root==NULL)
            return vector<int>();
        vector<int> result;
        preorder(root,result);
        return result;
    }
    vector<int> preorder(TreeNode *root,vector<int>& result) {
        if(root){
            result.push_back(root->val);
            preorder(root,result);
            preorder(root->right,result);
        }
    }

中序遍历：

非递归：

   vector<int> inorderTraversal(TreeNode *root) {
        vector<int> result;
        if(root==NULL)
            return result;
        stack<TreeNode*> trees;
        while(!trees.empty()||root){
            while(root){
                trees.push(root);
                root=root->left;
            }
            if(!trees.empty()){
                root=trees.top();
                result.push_back(root->val);
                trees.pop();
                root=root->right;
            }
        }
        return result;
    }

递归：

  vector<int> inorderTraversal(TreeNode *root) {
        vector<int> result;
        if(root==NULL)
            return result;
        inorder(root,result);
        return result;
    }
    void inorder(TreeNode* root,vector<int>& result){
        if(root==NULL)
            return;
        inorder(root->left,result);
        result.push_back(root->val);
        inorder(root->right,result);
    }

后序遍历

非递归：

  vector<int> inorderTraversal(TreeNode *root) {
        if(root==NULL)
            return vector<int>();
        vector<int> result;
        stack<TreeNode*> trees;
        TreeNode* p=root;
        TreeNode* pre=NULL;  //记录上一次访问的节点
        //将节点移动到最左节点
        while(p){
        	trees.push(p);
            p=p->left;
        }
        
        while(!trees.empty()){
            p=trees.top();
            trees.pop();
            //如果当前节点的右子树为空或者已经遍历过右节点，才可以访问当前节点
            if(p->right==NULL||pre=p->right){
            	result.push_back(p->val);
                pre=p;
            }
            else{   //否则遍历当前节点的右子树
                trees.push(p);
                p=p->right;
                while(p){
                    trees.push(p);
               		p=p->left; 
                }
            }
        }
        
        return result;
    }

第二种解法：

二叉树的后序遍历顺序为，root->left, root->right, root，因此需要保存根节点的状态。显然使用栈来模拟递归的过程，但是难点是怎么从root->right转换到root

对于节点p可以分情况讨论

1. p如果是叶子节点，直接输出

2. p如果有孩子，且孩子没有被访问过，则按照右孩子，左孩子的顺序依次入栈

3. p如果有孩子，而且孩子都已经访问过，则访问p节点

 保存最后一个访问的节点last，如果满足  (p->right==NULL && last ==p->left) || last==p->right，那么显然p的孩子都访问过了，接下来可以访问p

代码：

vector<int> postOrder(TreeNode *root)
  {
      vector<int> res;
      if(root == NULL) return res;
  
      TreeNode *p = root;
      stack<TreeNode *> sta;
      TreeNode *last = root;
      sta.push(p);
     while (!sta.empty())
     {
         p = sta.top();
         if( (p->left == NULL && p->right == NULL) || (p->right == NULL && last == p->left) || (last == p->right) )
         {
             res.push_back(p->val);
            last = p;
             sta.pop();
         }
         else 
         {
             if(p->right)
                sta.push(p->right);
             if(p->left)
                 sta.push(p->left);
         }
 
     } 
     return res;
}

递归：

   vector<int> inorderTraversal(TreeNode *root) {
        if(root==NULL)
            return vector<int>();
        vector<int> result;
        postorder(root,result);
  
        return result;
    }
    void postorder(TreeNode* root,vector<int>& result){
        if(root==NULL)
            return;
        postorder(root->left,result);
        postorder(root->right,result);
        result.push_back(root->val);
        
    }