二叉树

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

void createBiTree(BiTree *t){ /* 先序遍历创建二叉树*/
	char s;
	BiTree q;
	printf("please input data:(exit for #)");
	s=getche();
	if(s=='#'){*t=NULL; return;}
	q=(BiTree)malloc(sizeof(struct BTNode));
	if(q==NULL){printf("Memory alloc failure!"); exit(0);}
	q->data=s;
	*t=q;
	createBiTree(&q->lchild); /*递归建立左子树*/
	createBiTree(&q->rchild); /*递归建立右子树*/
}

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*/
        }
    }
}


void LevelOrder(BiTree t)   /*层次遍历*/
{
    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 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 NodeCount(BiTree t)         /*求二叉树总结点数*/
{
    if(t==NULL)
        return 0;       /*空树*/
    
    else
        return NodeCount(t->lchild)+NodeCount(t->rchild)+1;
}

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


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

int main(){
    BiTree t=NULL;
    createBiTree(&t);
    
    printf("\n\n先序遍历序列（递归）:");
    PreOrder(t);
    printf("\n\n中序遍历序列（递归）:");
    InOrder(t);
    printf("\n\n后序遍历序列（递归）:");
    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",NodeCount(t));
    printf("\n\n二叉树中叶子结点总数：");
    printf("%d\n",LeafCount(t));   
    printf("\n\n二叉树的深度：");
    printf("%d\n",Depth(t));   

    release(t);
    return 0;
}