二叉树（利用栈和队列实现递归和非递归遍历，构建等）

/**
二叉树的链式存储实现
队列实现层序插入和层序遍历
栈实现非递归的二叉树的遍历
**/

#include<stdio.h>
#include<malloc.h>
#include<math.h>
#include<string.h>

//二叉树元素类型
typedef char TElemType;

//二叉树节点
typedef struct BiTreeNode
{
TElemType QItem;
struct BiTreeNode *lchild;
struct BiTreeNode *rchild;
} BiTreeNode,*BiTree;

//栈节点
typedef struct StackNode
{
BiTree BNode;
struct StackNode *next;//下一个
}StackNode,*Stack;

//队列节点
typedef struct QueueNode
{
BiTree BNode;			//保存二叉树的节点指针
struct QueueNode *rear;//队尾，只有队首的rear才是正真的队尾
struct QueueNode *next;//元素的next是其相邻靠近队尾的元素
}QueueNode,*Queue;

/**
函数声明
**/
int InitStack(Stack &S);//初始化栈
int Push(Stack &S,BiTree BNode);//入栈
BiTree Pop(Stack &S);//出栈
int IsEmptyStack(Stack S);//栈是否为空

int InitQueue(Queue &Q);//初始化队列
int InQueue(Queue &Q,BiTree BNode);//入队
BiTree DeQueue(Queue &Q);//出队
int IsEmptyQueue(Queue Q);//队列是否为空

int InitBiTree(BiTree &T);//初始化二叉树
int CreateBiTree(BiTree &T,char *str);//层序建立二叉树（非队列实现）
void Qcreate(BiTree &T,char *str);//层序建立二叉树（队列实现）
void TravelLevel(BiTree T);//层序遍历二叉树(队列实现)
int IsEmptyBiTree(BiTree &T);//二叉树是否为空

int PrintTree1(BiTree T);//递归二叉树先序遍历
int PrintTree2(BiTree T);//递归二叉树中序遍历
int PrintTree3(BiTree T);//递归二叉树后序遍历

void PTravel(BiTree T);//非递归二叉树先序遍历
void MTravel(BiTree T);//非递归二叉树中序遍历
void LTravel(BiTree T);//非递归二叉树后序遍历

/////////////////////////////////栈////////////////////////////////////////////

//栈的初始化
int InitStack(Stack &S)
{
S=(Stack)malloc(sizeof(StackNode));
if(!S)
{
printf("初始化栈失败!");
return 0;
}
else
{
S->BNode=NULL;
S->next=NULL;
}
}

//入栈
int Push(Stack &S,BiTree BNode)
{
Stack p=S;
Stack temp;
//第一个元素
if(S->BNode==NULL)
{
S->BNode=BNode;
S->next=NULL;
return 1;
}
else{
//构造插入节点
InitStack(temp);
//入栈
temp->BNode=BNode;
temp->next=S;
S=temp;
return 2;
}
}

//出栈，并删除栈顶元素
BiTree Pop(Stack &S)
{
BiTree newb;
Stack temp=S;
//只有一个元素
if(S->next==NULL)
{
InitBiTree(newb);
newb=S->BNode;
S->BNode=NULL;
return newb;
}
else
{
S=S->next;
return temp->BNode;
}
}

//判断栈是否为空
int IsEmptyStack(Stack S)
{
if(S->BNode==NULL) return 1;
else return 0;
}

//////////////////////////////队列/////////////////////////////////////////////
//队列初始化
int InitQueue(Queue &Q)
{
Q=(Queue)malloc(sizeof(QueueNode));
if(!Q)
{
return 0;
}
else
{
Q->BNode=NULL;
Q->rear=NULL;
Q->next=NULL;
return 1;
}
}

//入队
int InQueue(Queue &Q,BiTree BNode)
{
//第一个元素
if(Q->BNode==NULL)
{
Q->BNode=BNode;
Q->rear=Q;
Q->next=NULL;
return 1;
}
else
{
//构造入队元素
Queue newq;
newq=(Queue)malloc(sizeof(QueueNode));
newq->BNode=BNode;
newq->next=NULL;
newq->rear=NULL;

Q->rear->next=newq;//插入
Q->rear=newq; //改变队首的rear
return 2;
}
}

//出队,返回队首指针，并删除之
BiTree DeQueue(Queue &Q)
{
Queue m=Q;
if(Q->next==NULL)
{
//保存仅有的一个元素
InitQueue(m);
m->BNode=Q->BNode;
m->next=NULL;
m->rear=NULL;

//队列置空
Q->BNode=NULL;
Q->rear=NULL;
Q->next=NULL;
}
else
{
Q=Q->next;
Q->rear=m->rear;
}
return m->BNode;
}

//判断队列是否为空
int IsEmptyQueue(Queue Q)
{
if(Q->BNode==NULL)
return 1;
else return 0;
}

//初始化二叉树
int InitBiTree(BiTree &T)
{
T=(BiTree)malloc(sizeof(BiTreeNode));
if(!T)
{
return 0;
}
else
{
T->QItem=NULL;
T->lchild=NULL;
T->rchild=NULL;
return 1;
}
}
/////////////////////////二叉树////////////////////////////////////////////////

//二叉树的构建,str为顺序节点存储的字符
int CreateBiTree(BiTree &T,char *str)
{
BiTree m,q;
q=T;
int length,i,j;
length=strlen(str);

if(length<1&&length>31)
return 0;
q->QItem=str[0];

for(i=2;i<=length;i++)
{
m=(BiTree)malloc(sizeof(BiTreeNode));
m->QItem= str[i-1];
m->lchild=NULL;
m->rchild=NULL;

for(j=1;j<(int)(log10(i)/log10(2));j++)//log2(i)为要添加节点的上一层
{
if((i/(int)pow(2,(int)(log10(i)/log10(2))-j))%2==0)//0为左孩子
{
if(q->lchild==NULL)
{
printf("输入错误,第%d个节点无父节点\n",i);
free(m);
return 0;
}
q=q->lchild;
}

else
{
if(q->rchild==NULL)
{
printf("输入错误，第%d个节点无父节点\n",i);
free(m);
return 0;
}
q=q->rchild;
}
}

//判断左右孩子
if(i%2==0)
{
q->lchild=m;
printf("左插入%d\n",i);
}
else
{
q->rchild=m;
printf("右插入%d\n",i);
}
q=T;
}
return 1;
}

//先序打印二叉树(递归实现)
int PrintTree1(BiTree T)
{
BiTree q=T;
if(q!=NULL)
{
printf("%c ",q->QItem);
PrintTree1(q->lchild);
PrintTree1(q->rchild);
}
return 1;
}

//中序遍历二叉树(递归实现)
int PrintTree2(BiTree T)
{
BiTree q=T;
if(q!=NULL)
{
PrintTree2(q->lchild);
printf("%c ",q->QItem);
PrintTree2(q->rchild);
}
return 1;
}

//后序遍历二叉树(递归实现)
int PrintTree3(BiTree T)
{
BiTree q=T;
if(q!=NULL)
{
PrintTree3(q->lchild);
PrintTree3(q->rchild);
printf("%c ",q->QItem);
}
return 1;
}

//判断二叉树是否为空
int IsEmptyBiTree(BiTree &T)
{
if(T==NULL)
{
return 1;
}
else
{
return 0;
}
}

//二叉树的层序遍历,队列实现
void TravelLevel(BiTree T)
{
Queue Q;
InitQueue(Q);
BiTree tree=T,m;
InQueue(Q,tree);//根节点入队

while(IsEmptyQueue(Q)!=1)
{
m=DeQueue(Q);
printf("%c ",m->QItem);
InQueue(Q,m->lchild);
InQueue(Q,m->rchild);
}
}

//二叉树先序遍历，非递归实现 (栈)
void PTravel(BiTree T)
{
Stack stack;
BiTree t=T;
InitStack(stack);

while(IsEmptyStack(stack)!=1||IsEmptyBiTree(t)!=1)
{
while(IsEmptyBiTree(t)!=1)//二叉树非空
{
printf("%c ",t->QItem);
Push(stack,t);
t=t->lchild;
}
if(IsEmptyStack(stack)!=1)//栈非空
{
t=Pop(stack);
t=t->rchild;
}
}
}

//二叉树中序遍历，非递归实现 (栈)
void MTravel(BiTree T)
{
Stack stack;
BiTree t=T;
InitStack(stack);

while(IsEmptyStack(stack)!=1||IsEmptyBiTree(t)!=1)
{
while(IsEmptyBiTree(t)!=1)//二叉树非空
{
Push(stack,t);
t=t->lchild;
}
if(IsEmptyStack(stack)!=1)//栈非空
{
t=Pop(stack);
printf("%c ",t->QItem);
t=t->rchild;
}
}
}

//二叉树后序遍历，非递归实现(栈)
void LTravel(BiTree T)
{
Stack stack;
BiTree cur;	//当前节点
BiTree pre=NULL;//前一次访问节点

InitStack(stack);
Push(stack,T);

while(IsEmptyStack(stack)!=1)
{
cur=stack->BNode;
//当前节点无左右孩子则输出
//上次访问节点不空且（上次访问节点和当前节点的左孩子或右孩子相同）,则输出
if((cur->lchild==NULL&&cur->rchild==NULL)||(pre!=NULL&&(pre==cur->lchild||pre==cur->rchild)))
{
printf("%c ",cur->QItem);
Pop(stack);
pre=cur;
}
else
{
if(cur->rchild!=NULL)
Push(stack,cur->rchild);
if(cur->lchild!=NULL)
Push(stack,cur->lchild);
}
}
}

//层序建立二叉树（队列实现）
void Qcreate(BiTree &T,char *str)
{
int len=strlen(str);
int i=1;
Queue Q;
BiTree temp,b;
InitQueue(Q);

//根节点
InitBiTree(b);
b->QItem=str[0];
InQueue(Q,b);
T=b;

while(IsEmptyQueue(Q)!=1)
{

temp=DeQueue(Q);

if(str[i]!='\0')
{
InitBiTree(b);
b->QItem=str[i];
InQueue(Q,b);
temp->lchild=b;
}
i++;
if(str[i]!='\0')
{
InitBiTree(b);
b->QItem=str[i];
InQueue(Q,b);
temp->rchild=b;
}
i++;
}

}

int main()
{
char s[80]="12345678";
BiTree T=NULL;
InitBiTree(T);
//CreateBiTree(T,s);
Qcreate(T,s);
IsEmptyBiTree(T);
printf("递归先序遍历二叉树:\n");
PrintTree1(T);
printf("\n非递归先序遍历二叉树:\n");
PTravel(T);
printf("\n递归中序遍历二叉树:\n");
PrintTree2(T);
printf("\n非递归中序遍历二叉树:\n");
MTravel(T);
printf("\n递归后序遍历二叉树:\n");
PrintTree3(T);
printf("\n非递归后序遍历二叉树:\n");
LTravel(T);
printf("\n层序遍历二叉树:\n");
TravelLevel(T);
printf("\n");
return 1;
}