从先序中序重建二叉树输出层序后序
实验题目(共6题, 第2题)
| 标题： | 从先序中序重建二叉树输出层序后序 |
| 时 限： | 5000 ms |
| 内存限制： | 20000 K |
| 总时限： | 10000 ms |
| 描述： |
由树的先序和中序遍历生成树的层序遍历后序遍历
给定一个树的先序和中序的遍历结果，构建一棵树，并输出这个棵树的层序遍历和后序遍历结果
注：这棵树的结点是由整数描述 |
| 输入： |
树结点总数m
先序输出序列
中序输出序列 |
| 输出： |
层序输出序列
后续输出序列 |
| 输入样例： |
10
1 2 5 10 3 6 13 7 14 15
2 10 5 1 6 13 3 14 7 15 |
| 输出样例： |
1 2 3 5 6 7 10 13 14 15
10 5 2 13 6 14 15 7 3 1 |
| 提示： |
先序遍历的第一个输出是根结点 |
|
来源： #include<stdio.h>
#include<stdlib.h>
#define STACK_INIT_SIZE 100 // 存储空间初始分配量
#define STACKINCREMENT 10 // 存储空间分配增量
int *pre;
int *in;
typedef struct BiTNode
{
int data;
struct BiTNode *lchild;
struct BiTNode *rchild;
}BiTNode,*BiTree;
struct SqStack
{
BiTree *base; // 在栈构造之前和销毁之后，base的值为NULL
BiTree *top; // 栈顶指针
int stacksize; // 当前已分配的存储空间，以元素为单位
}; // 顺序栈
typedef struct QNode
{
BiTree data;
QNode *next;
}*QueuePtr;
struct LinkQueue
{
QueuePtr front,rear; // 队头、队尾指针
};
void LevelOrderTraverse(BiTree T);
void PostOrderTraverseNonRecursive(BiTree T);
void InitStack(SqStack &S);
void Pop(SqStack &S,BiTree &e);
void Push(SqStack &S,BiTree e);
int GetTop(SqStack S,BiTree &e);
int StackEmpty(SqStack S);
void DeQueue(LinkQueue &Q,BiTree &e);
void EnQueue(LinkQueue &Q,BiTree e);
int QueueEmpty(LinkQueue Q);
void InitQueue(LinkQueue &Q);
BiTree restore(int *pre,int *in,int n);
int main()
{
BiTree T;
int n,i;
scanf("%d",&n);
pre=(int *)malloc(n*sizeof(int));
in=(int *)malloc(n*sizeof(int ));
for(i=0;i<n;i++)
{
scanf("%d",pre+i);
}
for(i=0;i<n;i++)
{
scanf("%d",in+i);
}
T=restore(pre,in,n);
LevelOrderTraverse(T);
printf("\n");
PostOrderTraverseNonRecursive(T);
free(pre);
free(in);
return 0;
}
BiTree restore(int *pre,int *in,int n)
{
if(n==0) return 0;
BiTree p;
int *rpos;
int k;
p=(BiTree)malloc(sizeof(BiTNode));
if(!p)
{
printf("out of space!\n");
exit(0);
}
p->data=*pre;
for(rpos=in;rpos<in+n;rpos++)
{
if(*rpos==*pre) break;
}
k=rpos-in;
p->lchild=restore(pre+1,in,k);
p->rchild=restore(pre+1+k,rpos+1,n-1-k);
return p;
}
void LevelOrderTraverse(BiTree T)
{
LinkQueue q;
BiTree a;
if(T)
{
InitQueue(q);
EnQueue(q,T);
while(!QueueEmpty(q))
{
DeQueue(q,a);
printf("%d ",a->data);
if(a->lchild!=NULL)
EnQueue(q,a->lchild);
if(a->rchild!=NULL)
EnQueue(q,a->rchild);
}
}
}
void PostOrderTraverseNonRecursive(BiTree T)
{
BiTree p;
if(T==NULL) return;
SqStack S1, S2;
InitStack(S1);
InitStack(S2);
Push(S1, T);
while (!StackEmpty(S1))
{
Pop(S1, p);
Push(S2, p);
if (p->lchild != NULL) Push(S1, p->lchild);
if (p->rchild != NULL) Push(S1, p->rchild);
}
while (!StackEmpty(S2))
{
Pop(S2, p);
printf("%d ",p->data);
}
}
void InitStack(SqStack &S)
{
// 构造一个空栈S
if(!(S.base=(BiTree *)malloc(STACK_INIT_SIZE*sizeof(BiTree))))
exit(0); // 存储分配失败
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
}
int StackEmpty(SqStack S)
{
// 若栈S为空栈，则返回1，否则返回0
if(S.top==S.base)
return 1;
else
return 0;
}
int GetTop(SqStack S,BiTree &e)
{
// 若栈不空，则用e返回S的栈顶元素，并返回1；否则返回-1
if(S.top>S.base)
{
e=*(S.top-1);
return 1;
}
else
return 0;
}
void Push(SqStack &S,BiTree e)
{
// 插入元素e为新的栈顶元素
if(S.top-S.base>=S.stacksize) // 栈满，追加存储空间
{
S.base=(BiTree *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(BiTree));
if(!S.base)
exit(0); // 存储分配失败
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*(S.top)++=e;
}
void Pop(SqStack &S,BiTree &e)
{
// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回1；否则返回-1
if(S.top==S.base)
exit(0);
e=*--S.top;
}
void InitQueue(LinkQueue &Q)
{
// 构造一个空队列Q
if(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))
exit(0);
Q.front->next=NULL;
}
int QueueEmpty(LinkQueue Q)
{
// 若Q为空队列,则返回TRUE,否则返回FALSE
if(Q.front==Q.rear)
return 1;
else
return 0;
}
void EnQueue(LinkQueue &Q,BiTree e)
{
// 插入元素e为Q的新的队尾元素
QueuePtr p;
if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败
exit(0);
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
}
void DeQueue(LinkQueue &Q,BiTree &e)
{
// 若队列不空,删除Q的队头元素,用e返回其值,并返回1,否则返回0
QueuePtr p;
if(Q.front==Q.rear)
exit(0);
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if(Q.rear==p) Q.rear=Q.front;
free(p);
}
|
