二叉树的三种遍历

1）前序遍历

//递归算法
void pre(Btree* t,void(*visit)())
{
      if(!t)
      return;
      if(t)
      {
            visit(t->elem);
            pre(t->lchild);
            pre(t->rchild);
      }
}

//非递归算法
pre(Btree* t,void(*visit)())
{
    BtreeNode* p=t;
    stack* s;
    while(p||!s.empty())
    {
        while(p)
        {
            visit(p->elem);
                s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.pop();
            p=p->lchild;
        }
    }
}

2）中序遍历

//递归算法
mid(Btree*t)
{
      if(!t)
        return;
      if(t)
     { 
            mid(t->lchild);
            visit(t);
            mid(t->rchild);
      }
}//非递归算法

void mid(Btree* t,void(*visit)())
{
    BtreeBode* p=t;
    stack* s;
    while(p||s.empty())
    {
        while(p)
        {
     
                s.push(p);
                p=p->lchild;

        }
        if(!s.empty())
        {
            p=s.pop();
            visit(p->elem);
            p=p->rchild;
        }
    }
}

3）后序遍历

//递归算法
rear(Btree* t,void(*visit()))
{
        if(!t)
          return;
       if(t)
        {
               rear(t->lchild);
               rear(t->rchild);
               visit(t-elem);
        }
}

//非递归算法
rear(Btree* t,void(*visit())())
{
    BtreeNode* pre=NULL,* p;
    stack s;
    s.push(p);
    while(p||!s.empty())
    {
        p=s.top();
        if((!p->lchild&&p->rchild)||((!pre)&&(pre=p->lchild||pre=p->rchild)))
        {
            visit(p->elem);
            s.pop();
            pre=p;
        }
        else
        {
            if(p->rchild)
                s.push(p->rchild);
            if(p->lchild)
                s.push(p->lchild);
        }
    }
}