二叉树的先序，中序，后序遍历

先序遍历——按照“根节点-左孩子-右孩子”的顺序进行访问。

（1）递归方法
    void preOrder1(BinTree *root)     //递归前序遍历 
     {
         if(root!=NULL)
        {
            cout<<root->data<<" ";
            preOrder1(root->lchild);
            preOrder1(root->rchild); 
        }
     }


（2）非递归方法
 利用栈，先进后出的原理。先将根节点压入栈底，最后从叶子节点一步一步输出

void preOrder2(BinTree *root)      //非递归前序遍历 
{
    stack<BinTree*> s;            //创建一个空栈，这个栈存储的是树的节点
    BinTree *p=root;             //定义用来指向当前访问的节点的指针
    while(p!=NULL||!s.empty())  // 直到当前节点 p为NULL 并且 栈空 时，循环结束  
    {
        while(p!=NULL)
        {
            cout<<p->data<<" ";    //从根节点开始，输出当前节点  
            s.push(p);            // 将节点其入栈
            p=p->lchild;         //置其左孩子为当前节点，直至其没有左孩子，及当前节点为NULL  
        }
        if(!s.empty())          //如果当前节点pCur为NULL且栈不空，则将栈顶节点出栈
        {
            p=s.top();
            s.pop();           // 出栈
            p=p->rchild;      //同时置其右孩子为当前节点,循环判断，直至pCur不为空  
        }
    }



中序遍历——按照“左孩子-根节点-右孩子”的顺序进行访问。
（1）递归方法
    void preOrder1(BinTree *root)     //递归中序遍历 
     {
         if(root!=NULL)
        {
            preOrder1(root->lchild);            
            cout<<root->data<<" ";
            preOrder1(root->rchild); 
        }
     }

（2）非递归方法
 利用栈，先进后出的原理。先将根节点压入栈底，最后从叶子节点一步一步输出,不一样的是输出位置

void preOrder2(BinTree *root)      //非递归前序遍历 
{
    stack<BinTree*> s;            //创建一个空栈，这个栈存储的是树的节点
    BinTree *p=root;             //定义用来指向当前访问的节点的指针
    while(p!=NULL||!s.empty())  // 直到当前节点 p为NULL 并且 栈空 时，循环结束  
    {
        while(p!=NULL)
        {
          
            s.push(p);            // 将节点其入栈
            p=p->lchild;         //置其左孩子为当前节点，直至其没有左孩子，及当前节点为NULL  
        }
        if(!s.empty())          //如果当前节点pCur为NULL且栈不空，则将栈顶节点出栈
        {
            p=s.top();
            cout<<p->data<<" "; 
            s.pop();           // 输出当前节点 
            p=p->rchild;      //同时置其右孩子为当前节点,循环判断，直至pCur不为空  
        }
    }



后序遍历——按照“左孩子-右孩子-根节点”的顺序进行访问。

（1）递归方法
    void preOrder1(BinTree *root)     //递归中序遍历 
    {
       if(root!=NULL)
         { 
           preOrder1(root->left);
           preOrder1(root->right);
           cout<<root->data<<"  ";
         }

       return 0;
    }


（2）非递归方法
 利用栈，先进后出的原理。先将根节点压入栈底，最后从叶子节点一步一步输出,不一样的是输出位置

void postOrder3(BinTree *root)     //非递归后序遍历
  {
      stack<BinTree*> s;
      BinTree *cur;                      //当前结点 
      BinTree *pre=NULL;                 //前一次访问的结点 
      s.push(root);
      while(!s.empty())
      {
          cur=s.top();
         if((cur->lchild==NULL&&cur->rchild==NULL)||
            (pre!=NULL&&(pre==cur->lchild||pre==cur->rchild)))
         {
             cout<<cur->data<<" ";  //如果当前结点没有孩子结点或者孩子节点都已被访问过 
             s.pop();
             pre=cur; 
         }
         else
         {
             if(cur->rchild!=NULL)
                 s.push(cur->rchild);
             if(cur->lchild!=NULL)    
                 s.push(cur->lchild);
         }
     }    
 }