数据结构—二叉树层次遍历

/*
（1）二叉树的层次遍历；
（2）假设二叉树采用二叉链存储结构，设计一个算法输出从根节点到每个叶子节点的路径的逆
（即求叶子节点及其所有祖先节点的序列）。
*/
#include <iostream>
#include <malloc.h>
#define MaxSize 100
typedef char ElemType;
using namespace std;
typedef struct node
{
ElemType data;
struct node *lchild;
struct node *rchild;
} BTNode;

void CreateBTNode(BTNode *&b,char *str)   //创建二叉树
{
BTNode *St[MaxSize],*p;
int top=-1,k,j=0;
char ch;
b=NULL;
ch=str[j];
while(ch!='\0')
{
switch(ch)
{
case '(':
top++;
St[top]=p;
k=1;
break;
case ')':
top--;
break;
case ',':
k=2;
break;
default:
p=(BTNode *)malloc(sizeof(BTNode));
p->data=ch;
p->lchild=p->rchild=NULL;
if(b==NULL)
b=p;
else
{
switch(k)
{
case 1:
St[top]->lchild=p;
break;
case 2:
St[top]->rchild=p;
break;
}
}
}
j++;
ch=str[j];
}
}

/*
层次遍历：
先将根节点进队，在队不为空时循环：从队列中出列一个节点*p,访问它；
若它有左孩子节点，将左孩子节点进队； 若它有右孩子节点，将右孩子节点进队。
如此循环，直到队空为止。
*/
void LevelOrder(BTNode *b)
{
BTNode *p;
BTNode *qu[MaxSize];    //定义环形队列，存放节点指针
int front,rear;
front=rear=-1;
rear++;
qu[rear]=b;          //根节点指针进队列
while(front!=rear)
{
front=(front+1)%MaxSize;   //访问每个子树的根节点
p=qu[front];
cout<<p->data;
if(p->lchild!=NULL)        //有左孩子时将其进队
{
rear=(rear+1)%MaxSize;
qu[rear]=p->lchild;
}
if(p->rchild!=NULL)        //有右孩子时将其进队
{
rear=(rear+1)%MaxSize;
qu[rear]=p->rchild;
}
}
}

/*
非环形顺序队列qu，将所有已访问过的节点指针进队，并在队列中保存双亲节点的位置。
当找到一个叶子节点时，在队列中通过双亲节点的位置输出根节点到叶子节点的路径的逆。
*/
void AllPath(BTNode *b)
{
struct snode
{
BTNode *node;   //存放当前节点的指针
int parent;     //存放双亲节点在队列中的位置
}qu[MaxSize];       //定义非环形队列
BTNode *q;
int front,rear,p;
front=rear=-1;
rear++;
qu[rear].node=b;     //根节点指针进入队列
qu[rear].parent=-1;  //根节点没有双亲节点
while(front!=rear)
{
front++;
q=qu[front].node;  //队头出队列，该节点仍在qu中
if(q->lchild==NULL&&q->rchild==NULL)   //*q为叶子节点
{
p=front;                        //输出*q到根节点的路径序列
while(qu[p].parent!=-1)
{
cout<<qu[p].node->data<<"->";
p=qu[p].parent;
}
cout<<qu[p].node->data<<endl;
}
if(q->lchild!=NULL)                  //*q有左孩子时将左孩子进队列
{
rear++;
qu[rear].node=q->lchild;
qu[rear].parent=front;
}
if(q->rchild!=NULL)                  //*q有右孩子时将右孩子进队列
{
rear++;
qu[rear].node=q->rchild;
qu[rear].parent=front;
}
}
}

int main()
{
BTNode *b;
CreateBTNode(b,"A(B(D(,G)),C(E,F))");
cout<<"层次遍历：";
LevelOrder(b);
cout<<endl;
cout<<"输出根节点到叶子节点的路径的逆："<<endl;
AllPath(b);
cout<<endl;
return 0;
}