二叉树模板 先中后序遍历，非递归算法，层次遍历，叶子结点数，深度

#include <iostream>
#include<stdio.h>
#include<malloc.h>
#include<queue>
#define MAX 50
using namespace std;
typedef struct BTNode        /*节点结构声明*/
{
    char data ;               /*节点数据*/
    struct BTNode *lchild;
    struct BTNode *rchild ;  /*指针*/
}*BiTree;
int nodenum;
int leavesnum;

BiTree createBiTree(BiTree t)  /* 先序遍历创建二叉树*/
{
    char s;
    printf("\nplease input data:(exit for #)");
    s=getchar();
    if(s=='#')
    {
        t=NULL;
        return t;
    }
    t=(BiTree)malloc(sizeof(struct BTNode));
    if(t==NULL)
    {
        printf("Memory alloc failure!");
        return t;
    }
    t->data=s;
    nodenum++;                          /*二叉树结点计数*/
    t->lchild=createBiTree(t->lchild); /*递归建立左子树*/
    t->rchild=createBiTree(t->rchild); /*递归建立右子树*/
    if(t->lchild==NULL&&t->rchild==NULL)
        leavesnum++;                    /*叶子结点计数*/
    return t;
}

void PreOrder(BiTree p)   /* 先序遍历二叉树*/
{
    if ( p!= NULL )
    {
        printf("%c", p->data);
        PreOrder( p->lchild ) ;
        PreOrder( p->rchild) ;
    }
}
void InOrder(BiTree p)   /* 中序遍历二叉树*/
{
    if( p!= NULL )
    {
        InOrder( p->lchild ) ;
        printf("%c", p->data);
        InOrder( p->rchild) ;
    }
}
void PostOrder(BiTree p)   /* 后序遍历二叉树*/
{
    if ( p!= NULL )
    {
        PostOrder( p->lchild ) ;
        PostOrder( p->rchild) ;
        printf("%c", p->data);
    }
}

void Preorder_n(BiTree p)  /*先序遍历的非递归算法*/
{
    BiTree stack[MAX],q;
    int top=0,i;
    for(i=0; i<MAX; i++)
        stack[i]=NULL; /*初始化栈*/
    q=p;
    while(q!=NULL)
    {
        printf("%c",q->data);
        if(q->rchild!=NULL)
            stack[top++]=q->rchild;
        if(q->lchild!=NULL)
            q=q->lchild;
        else if(top>0)
            q=stack[--top];
        else
            q=NULL;
    }
}

void InOrder_n(BiTree t)     /*中序遍历二叉树的非递归算法*/
{
    BiTree stack[MAX],p;   /*定义顺序栈stack，最大容量为100*/
    int top=0;               /*栈顶指针top*/
    p=t;
    do
    {
        while(p!=NULL)       /*顺着左链走到尽头*/
        {
            stack[top++]=p;  /*当二叉树不空的时候根指针入栈*/
            p=p->lchild;     /*顺着左链搜索知道最左端叶子结点*/
        }
        if(top>0)
        {
            p=stack[top-1];                   /*栈不空时取出栈顶元素*/
            printf("%c",p->data);   /*输出当前访问的根结点*/
            top--;
            p=p->rchild;      /*顺着右链搜索*/
        }
    }
    while(top!=0||p!=NULL);  /*遍历未结束时，继续访问结点*/
}

void PostOrder_n(BiTree t)  /*后序遍历二叉树的非递归算法*/
{
    if(t==NULL)
        return ;
    BiTree stack[MAX],pnow=t,plast=NULL;          /*pnow当前访问结点存根结点,plast上次访问的结点，定义指针赋值NULL*/
    int top=0;                              /*栈顶充当指针作用的top*/
    while(pnow!=NULL)
    {
        stack[top++]=pnow;
        pnow=pnow->lchild;
    }                                           /*让pnow指向最左下的结点的左孩子，值为NULL*/
    while(top>0)
    {
        pnow=stack[top-1];      /*让pnow指向最左下的结点*/
        top--;                                 /*相当于栈顶元素出栈*/
        if(pnow->rchild==NULL||pnow->rchild==plast)         /*如果右子树为空或右子树已访问过，访问根结点*/
        {
            printf("%c",pnow->data);
            plast=pnow;                 /*plast存已访问的最新结点*/
        }
        else                                    /*右子树不为空且未访问*/
        {
            stack[top++]=pnow;      /*左右根，要先输出右，根结点再次进栈*/
            pnow=pnow->rchild;      /*当前访问的结点更新为pnow的右子树*/
            while(pnow!=NULL)
            {
                stack[top++]=pnow;
                pnow=pnow->lchild;
            }                                           /*找到该右子树的最左下结点更新pnow*/
        }
    }
}

int TreeCount(BiTree t)         /*求二叉树叶子结点数*/
{
    if(t==NULL)
        return 0;       /*空树*/
    else if((t->lchild==NULL)&&(t->rchild==NULL))
        return 1;
    else
        return TreeCount(t->lchild)+TreeCount(t->rchild);
}

int Depth(BiTree t)     /*求二叉树的深度*/
{
    int hl,hr;
    if(t==NULL)
        return 0;
    else
    {
        hl=Depth(t->lchild);
        hr=Depth(t->rchild);
        if(hl>=hr)
            return hl+1;
        else
            return hr+1;
    }
}

int TreeDepth(BiTree t)     /*求二叉树的深度*/
{
    int rightdep=0;
    int leftdep=0;
    if(t==NULL)
        return 0;
    leftdep=TreeDepth(t->lchild);
    rightdep=TreeDepth(t->rchild);
    return (leftdep>rightdep)?(leftdep+1):(rightdep+1);
}

void release(BiTree t)  /*释放二叉树空间*/
{
    if(t!=NULL)
    {
        release(t->lchild);
        release(t->rchild);
        free(t);
    }
}

void LevelOrder(BiTree t)   /*层次遍历*//*acm模板c++*/
{
    BiTree p=t;
    queue<BiTree>q;
    q.push(p);
    while(q.empty()!=1)
    {
        p=q.front();
        printf("%c",p->data);
        q.pop();
        if(p->lchild!=NULL)
            q.push(p->lchild);
        if(p->rchild!=NULL)
            q.push(p->rchild);
    }
}

int main()
{
    BiTree t=NULL;
    nodenum=0;
    leavesnum=0;
    t=createBiTree(t);
    printf("\n\nPreOrder the tree is:");
    PreOrder(t);
    printf("\n\nInOrder the tree is:");
    InOrder(t);
    printf("\n\nPostOrder the tree is:");
    PostOrder(t);
    printf("\n\n先序遍历序列（非递归）:");
    Preorder_n(t);
    printf("\n\n中序遍历序列（非递归）:");
    InOrder_n(t);
    printf("\n\n后序遍历序列（非递归）:");
    PostOrder_n(t);
    printf("\n\n层次遍历序列：");
    LevelOrder(t);
    printf("\n\n二叉树中结点总数：");
    printf("%d\n",nodenum);
    printf("\n\n二叉树中叶子结点总数：");
    printf("%d\n",leavesnum);    /*或者TreeCount(t)*/
    printf("\n\n二叉树的深度：");
    printf("%d\n",Depth(t));    /*或者TreeDepth(t)*/
    release(t);
    return 0;
}