二叉树 队列实现 模板

#include <iostream>
#include <cstdio>
#include <malloc.h>   //在本程序中空==0
using namespace std;
#define FLASE 0
#define TRUE 1
#define ERROR 0
#define OK 1
typedef int TElemType;
typedef int Status;
typedef struct BiTNode
{
TElemType data; //结点的值
BiTNode *lchild, *rchild;//左右孩子指针
}BiTNode,*BiTree;
typedef BiTree QElemType;
typedef struct QNode
{
QElemType data;
QNode *next;
}*QueueRtr;
struct LinkQueue
{
QueueRtr ifront,irear;
};
void DestroyBiTree(BiTree &T);
void InitQueue(LinkQueue &Q)
{
Q.ifront=Q.irear=(QueueRtr)malloc(sizeof(QNode));//生成头结点
if(!Q.ifront)
exit(0);
Q.ifront->next=NULL;//头结点的next域为空
}
void DestroyQueue(LinkQueue &Q)
{
while(Q.ifront) //Q.ifront不为空
{
Q.irear=Q.ifront->next;//Q.rear指向Q.front的下一个结点
free(Q.ifront);//释放Q.front所指的结点
Q.ifront=Q.irear; //Q.front指向Q,front的下一个结点
}
}

Status QueueEmpty(LinkQueue Q)
{
if(Q.ifront->next==NULL)
return TRUE;
else
return FLASE;
}
int QueueLength(LinkQueue Q)
{
int i=0;
QueueRtr p=Q.ifront;//p指向头结点
while(Q.irear!=p)  //p所指的不是尾结点
{
i++;
p=p->next; //p指向下一个结点
}
return i;
}
void EnQueue(LinkQueue &Q,QElemType e)
{//插入元素e为队列的新的队尾元素
QueueRtr p;
p=(QueueRtr)malloc(sizeof(QNode));
if(!p)
exit(0);
p->data=e;    //将e赋值给新结点
p->next=NULL;   //新结点的指针域为空
Q.irear->next=p;   //原队尾结点的指针指向新结点
Q.irear=p;  // 尾指针指向新结点
}
Status DeQueue(LinkQueue &Q,QElemType  &e)
{//若队列Q不空，删除Q的队头元素，用e返回其值
QueueRtr p;
if(Q.ifront==Q.irear)
return ERROR;
p=Q.ifront->next;//p指向队头
e=p->data;   //赋值
Q.ifront->next=p->next;//头节点指向下一个结点
if(Q.irear==p)  //s删除的是队尾结点
Q.irear=Q.ifront;
free(p);
return OK;
}
void QueueTraverse(LinkQueue &Q)
{
QueueRtr p=Q.ifront->next;
while(p)
{
printf("%d  ",p->data);
p=p->next;
}
printf("\n");
}
BiTree Point(BiTree T,TElemType s)
{//返回二叉树T中指向元素之为s的结点的指针
LinkQueue q;
QElemType a;
if(T)  //非空树
{
InitQueue(q);//初始化队列
EnQueue(q,T);//根指针入队
while(!QueueEmpty(q)) //队不为空
{
DeQueue(q,a); //出队，队列元素赋值给a；
if(a->data==s)   //a所指的结点的值为s
{
DestroyQueue(q);//销毁队列s
return a;
}
if(a->lchild) //有左孩子
EnQueue(q,a->lchild);  //入队左孩子
if(a->rchild) //有右孩子
EnQueue(q,a->rchild);  //入队右孩子

}
DestroyQueue(q); //销毁队列q;

}
return NULL; //二叉树中没有元素值为s的结点
}
TElemType LeftChild(BiTree T,TElemType e)
{//返回e的左孩子，若e无左孩子，则返回空
BiTree a;
if(T) //非空树
{
a=Point(T,e);   //a是指向结点e的指针;
if(a&&a->lchild) //T中存在结点e且e存在左孩子
return a->lchild->data;  //返回e的左孩子的值
}
return 0;

}
TElemType RightChild(BiTree T,TElemType e)
{//返回e的右孩子，若e无右孩子，则返回空
BiTree a;
if(T) //非空树
{
a=Point(T,e);   //a是指向结点e的指针;
if(a&&a->rchild) //T中存在结点e且e存在右孩子
return a->rchild->data;  //返回e的右孩子的值
}
return 0;
}
Status DeleteChild(BiTree p,int LR)
{//根据LR为0或1,p删除T中所指结点的左右子树
if(p) //p不为空
{
if(LR==0)//删除左子树
DestroyBiTree(p->lchild); //清空p所指结点的左子树
else if(LR==1)//删除右子树
DestroyBiTree(p->rchild); //清空p所指结点的右子树
return OK;
}
return ERROR;
}
void InitBiTree(BiTree &T)
{
T=NULL;
}
void DestroyBiTree(BiTree &T)
{
if(T){  //非空树
DestroyBiTree(T->lchild); //递归销毁左子树，如无左子树，则不执行任何操作
DestroyBiTree(T->rchild); //递归销毁右子树，如无右子树，则不执行任何操作
free(T);  //释放根节点
T=NULL;   //空指针赋值
}
}
void PreOrderTraverse(BiTree T)//先序递归遍历T
{
if(T)
{
printf("%d",T->data);   //先访问根节点
PreOrderTraverse(T->lchild);  //再先序遍历左子树
PreOrderTraverse(T->rchild);   //最后先序遍历右子树
}
}
void InOrderTraverse(BiTree T)//中序递归遍历T
{
if(T)
{
InOrderTraverse(T->lchild);  //先遍历左子树
printf("%d",T->data);     //在访问根节点
InOrderTraverse(T->rchild);  //最后遍历右子树
}
}
void PostOrderTraverse(BiTree T)
{
if(T)
{
PostOrderTraverse(T->lchild);  //先遍历左子树
PostOrderTraverse(T->rchild);  //再遍历右子树
printf("%d",T->data);     //在访问根节点
}
}
Status BiTreeEmpty(BiTree T)
{
if(T)
return FLASE;
else
return TRUE;
}
int BiTreeDepth(BiTree T)
{
int i,j;
if(!T)
return 0;//树的深度为0
i=BiTreeDepth(T->lchild); //i为左子树的深度
j=BiTreeDepth(T->rchild); //j为右子树的深度
return i>j?i+1:j+1;  //T的深度为其左右子树的深度中的大者+1
}
TElemType Root(BiTree T)//返回T的根
{
if(BiTreeEmpty(T)) //二叉树为空
return  0;
else
return T->data;
}
TElemType Value(BiTree p) //二叉树T存在，p指向T中的某个结点，结果返回p所指的结点
{
return p->data;
}
void  Assign(BiTree p,TElemType value)
{
p->data=value;
}
void CreateBiTree(BiTree &T)  //按照先序次序输入二叉树中结点的值
{
TElemType ch;
scanf("%d",&ch);
if(ch==0)  //当输入的值为0的时候结点的值为空
T=NULL;
else  //结点值不为空
{
T=(BiTree)malloc(sizeof(BiTNode));  //生成根节点
if(!T)
exit(0);
T->data=ch;
CreateBiTree(T->lchild);   //递归构造左子树
CreateBiTree(T->rchild);    //递归构造右子树
}
}
void LeveOrderTraverse(BiTree T)
{//层序遍历T
LinkQueue q;
QElemType a;
if(T)
{
InitQueue(q);
EnQueue(q,T);  //根指针入队
while(!QueueEmpty(q))  //队列不空
{
DeQueue(q,a);   //出队元素指针，赋给a
printf("%d",a->data);
if(a->lchild!=NULL)   //a有左孩子
EnQueue(q,a->lchild);  //入队a的左孩子
if(a->rchild!=NULL)  //a有右孩子
EnQueue(q,a->rchild);  //入队a的右孩子
}
printf("\n");
DestroyQueue(q);
}

}

TElemType Parent(BiTree T,TElemType e)
{//若e是T的非根节点，则返回他的双亲，否则返回空
LinkQueue q;
QElemType a;
if(T)
{
InitQueue(q);//初始化队列
EnQueue(q,T);  //树根指针入队
while(!QueueEmpty(q)); //队不空
{
DeQueue(q,a); //出队.队列元素赋给a
if((a->lchild&&a->lchild->data==e)||(a->rchild&&a->rchild->data==e))
return a->data; //返回e的双亲的值
else//若未找到e,则入队其左右孩子指针(如果非空)
{
if(a->lchild)  //a有左孩子
EnQueue(q,a->lchild); //入队左孩子指针
else if(a->rchild)
EnQueue(q,a-
4000
>rchild);
}

}
}
return 0;
}
TElemType LeftSibling(BiTree T,TElemType e)
{//返回e的左兄弟，若e是T的左孩子或无左兄弟，返回空
TElemType a;
BiTree p;
if(T)
{
a=Parent(T,e); //a为e的双亲
if(a!=0) //找到e的双亲
{
p=Point(T,a);//p为指向结点a的指针
if(p->lchild&&p->rchild&&p->rchild->data==e)//p存在左右孩子且右孩子是e
return p->lchild->data;  //返回p的左孩子
}
}
return 0;
}
TElemType RightSibling(BiTree T,TElemType e)
{//返回e的右兄弟，若e是T的右孩子或无右兄弟，返回空
TElemType a;
BiTree p;
if(T)
{
a=Parent(T,e); //a为e的双亲
if(a!=0) //找到e的双亲
{
p=Point(T,a);//p为指向结点a的指针
if(p->lchild&&p->rchild&&p->lchild->data==e)//p存在左右孩子且右孩子是e
return p->rchild->data;  //返回p的左孩子
}
}
return 0;
}
Status InsertChild(BiTree p,int LR,BiTree c)
{//LR为0或1，插入c为T中所指结点的左或右子树，p所指结点的原有左或右子树则成为C的右子树
if(p)
{
if(LR==0)//把二叉树c插为p所指向结点的左子树
{
c->rchild=p->lchild;//p所指向的原有左子树成为C的右子树
p->lchild=c;//二叉树c成为p的左子树
}
else//把二叉树c插为p所指结点的右子树
{
c->rchild=p->rchild;//p所指结点的原有右子树成为c的右子树
p->rchild=c;//二叉树c成为p的右子树

}
return OK;
}
return ERROR;
}
int main()
{
int i;
BiTree T;
TElemType e1;
InitBiTree(T);  //初始化二叉树T
printf("构造二叉树后,树是否为空?%d(1:是 0:否) 树的深度%d\n",BiTreeEmpty(T),BiTreeDepth(T));
e1=Root(T);
if(e1!=0)
printf("二叉树的根是%d\n",e1);
else
printf("无根\n");
CreateBiTree(T);
printf("建立二叉树后,树是否为空?%d(1:是 0:否) 树的深度\n",BiTreeEmpty(T),BiTreeDepth(T));
e1=Root(T);
if(e1!=0)
printf("二叉树的根是%d\n",e1);
else
printf("无根\n");
printf("先序遍历递归二叉树:\n");
PreOrderTraverse(T); printf("\n");
printf("中序遍历递归二叉树:\n");
InOrderTraverse(T);  printf("\n");
printf("后序遍历递归二叉树:\n");
PostOrderTraverse(T); printf("\n");

}