#include “stdio.h”
#include “string.h”
#include “malloc.h”
#define NULL 0
#define MAXSIZE 30
typedef struct BiTNode //定义二叉树数据结构
{
char data;
struct BiTNode *lchild,*rchild;
} BiTNode;
typedef struct Queue //定义顺序结构队列数据结构(层序遍历需要借助队列)
{
struct BiTNode * data[MAXSIZE];
int front,rear;
} Queue;
typedef struct Stack //定义顺序结构栈数据结构(非递归遍历二叉树需要借助栈)
{
struct BiTNode * data[MAXSIZE];
int top;
} Stack;
bool isEmpty(Queue *);//判队列是否空
bool InitStack(Stack *& s)//初始化栈
{
if(!(s=(Stack *)malloc(sizeof(Stack))))
{
return false;
}
else
{
s->top=-1;
}
}
bool isFullStack(Stack *s)//判栈是否满
{
if((s->top)==(MAXSIZE-1))
{
return true;
}
else
return false;
}
bool isEmptyStack(Stack *s)//判栈是否空
{
if((s->top)==-1)
{
return true;
}
else
return false;
}
bool push(Stack *s,BiTNode *&bitnode)//入栈
{
if(!isFullStack(s))
{
s->top++;
s->data[s->top]=bitnode;
return true;
}
else
return false;
}
bool pop(Stack *s,BiTNode *& bitnode)//入栈
{
if(s->top==-1)
{
return false;
}
else
{
bitnode=s->data[s->top];
(s->top)–;
return true;
}
}
bool InitQueue(Queue *& q)//初始化队列
{
if(!(q=(Queue *)malloc(sizeof(Queue))))
{
return false;
}
else
{
q->front=0;
q->rear=0;
return true;
}
}
void enQueue(Queue *q,BiTNode * data)//入队
{
if(q->front==(q->rear+1))
{
printf(“Queue is full\n”);
}
else
{
q->data[q->rear]=data;
q->rear=((q->rear)+1)%MAXSIZE;
}
}
void deQueue(Queue *q,BiTNode *& data)//出队
{
if(!isEmpty(q))
{
data=q->data[q->front];
q->front=(q->front+1)%MAXSIZE;
}
}
bool isEmpty(Queue *q)//判队空
{
if(q->front==q->rear)
{
return true;
}
else
return false;
}
void preCreate(BiTNode *& T) //先序遍历建立二叉树
{
char ch;
ch=getchar();
if(ch==’#’)
T=NULL;
else
{
if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))
printf(“Error!”);
T->data=ch;
preCreate(T->lchild);
preCreate(T->rchild);
}
}
void inOrderNo(BiTNode * T)//非递归进行中序遍历,借助于栈
{
BiTNode * temp=T;
Stack *s;
InitStack(s);
while(temp!=NULL||!isEmptyStack(s))
{
if(temp!=NULL)
{
if(push(s,temp))
temp=temp->lchild;
else
printf(“压栈失败\n”);
}
else
{
if(pop(s,temp))
{
printf(“%c”,temp->data);
temp=temp->rchild;
}
else
printf(“弹栈失败\n”);
}
}
}
void levelOrder(BiTNode * T)//层序遍历,借助于队列
{
BiTNode * node=T;
Queue * queue=NULL;
InitQueue(queue);
enQueue(queue,T);
while(!isEmpty(queue))
{
deQueue(queue,T);
printf(“%c”,T->data);
if(T->lchild!=NULL)
enQueue(queue,T->lchild);
if(T->rchild!=NULL)
enQueue(queue,T->rchild);
}
}
int main()
{
BiTNode * bitree=NULL;
preCreate(bitree);//先序遍历建立二叉树
printf(“\n中序遍历:(非递归)”);
inOrderNo(bitree);
printf(“\n层序遍历:”);
levelOrder(bitree);
return 0;
}
