二叉树的三种递归遍历方式和非递归方式

递归遍历

1、前序遍历
void PreOrderTraverse(BiTreeNode *r)
    {
        if(r)
        {
            cout<<r->data;
            PreOrderTraverse(r->lchild );
            PreOrderTraverse(r->rchild );
        }

    }
2、中序遍历
    void InOrderTraverse(BiTreeNode *r)
    {
        if(r)
        {   
            InOrderTraverse(r->lchild );
            cout<<r->data;
            InOrderTraverse(r->rchild );
        }

    }
3、后续遍历
    void PostOrderTraverse(BiTreeNode *r)
    {
        if(r)
        {       
            PostOrderTraverse(r->lchild );
            PostOrderTraverse(r->rchild );
            cout<<r->data;
        }

    }

非递归遍历

1、前序遍历
void preOrder2(BinTree *root)   
{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            cout<<p->data<<" ";
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            s.pop();
            p=p->rchild;
        }
    }
}

2、中序遍历
void inOrder2(BinTree *root)      //非递归中序遍历
{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            cout<<p->data<<" ";
            s.pop();
            p=p->rchild;
        }
    }    
}

3、后续遍历（三种非递归方式中较难的一种）
// 巧妙的方法：前序遍历 根->左->右 变成 根->右->左 结果再reverse一下
 vector<int> postorderTraversal(TreeNode *root)
   {
       vector<int> res;
       if(!root)
           return res;
       stack<TreeNode *> st;
       st.push(root);
       while(st.size())
       {
           TreeNode *temp = st.top();
           st.pop();
           res.push_back(temp->val);
           if(temp->left)
               st.push(temp->left);
           if(temp->right)
               st.push(temp->right);
       }
       reverse(res.begin(),res.end());
       return res;
   }