从先序中序重建二叉树输出层序后序

实验题目(共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);
}
posted @ 2011-05-22 11:52  itbird  Views(1227)  Comments(0)    收藏  举报