哈工大 数据结构与算法 作业3-树形结构及其应用

作业题目：二叉树存储结构的建立、遍历和应用

树型结构的遍历是树型结构算法的基础，本实验要求编写程序演示二叉树 的存储结构的建立方法、遍历过程以及应用。

作业要求：

1．编写建立二叉树的二叉链表存储结构（左右链表示）的程序，并以适当的形 式显示和保存二叉树；

2．采用二叉树的二叉链表存储结构，编写程序实现二叉树的先序、中序和后序 遍历的递归和非递归算法以及层序遍历算法，并以适当的形式显示和保存二叉树 及其相应的遍历序列；

3．设计并实现判断任意一棵二叉树是否为完全二叉树的算法。

4．设计并实现计算任意一棵二叉树的宽度的（递归或非递归）算法。二叉树的 宽度是指其各层结点数的最大值。 注：二叉树的显示（输出）以适当的形式即可。不必采用可视化的图形方式。

#include<stdio.h>
#include<stdlib.h>
#define MAX 100
typedef struct btree
{
    int data;
    struct btree *lchild;
    struct btree *rchild;
}BTREE;
typedef struct stack
{
    int top;
    BTREE *element[MAX];
}STACK;
typedef struct link
{
    BTREE *BT;
    struct link*next;
}LINK;
typedef struct queue
{
    LINK *front;
    LINK *rear;
}QUEUE;
int Empty(BTREE *BT);
// BTREE *Lchild(BTREE *BT);
// BTREE *Rchild(BTREE *BT);
void CreateBT(BTREE * &BT);
void PreOrder(BTREE *BT,FILE *fp);
void NPreOrder(BTREE *BT,FILE *fp);
void InOrder(BTREE *BT,FILE *fp);
void NInOrder(BTREE *BT,FILE *fp);
void PostOrder(BTREE *BT,FILE *fp);
void NPostOrder(BTREE *BT,FILE *fp);
void LevelOrder(BTREE *BT,FILE *fp);
int CompleteBitree(BTREE *BT);
int Width(BTREE *BT);
void Display(BTREE *BT);
void WriteFile(BTREE *BT,FILE *fp);
void MakeNull(STACK &S);
int Empty(STACK S);
BTREE * Top(STACK S);
void Pop(STACK &S);
void Push(BTREE *BT,STACK &S);
void MakeNull(QUEUE &Q);
int Empty(QUEUE Q);
BTREE *Front(QUEUE Q);
void EnQueue(BTREE *BT,QUEUE &Q);
void DeQueue(QUEUE &Q);
int main()
{
    BTREE *BT=NULL;
    FILE *fp=NULL;
    if((fp=fopen("btree.txt","a"))==NULL)
    {
        printf("Fail to open btree.txt!\n");
        exit(0);
    }
    CreateBT(BT);
    PreOrder(BT,fp);
    printf("\n");
    fprintf(fp,"\n");
    NPreOrder(BT,fp);
    InOrder(BT,fp);
    printf("\n");
    fprintf(fp,"\n");
    NInOrder(BT,fp);
    PostOrder(BT,fp);
    printf("\n");
    fprintf(fp,"\n");
    NPostOrder(BT,fp);
    LevelOrder(BT,fp);
    if(CompleteBitree(BT))
        printf("The bitree is a complete bitree!\n");
    else
        printf("The btree is not a complete bitree!\n");
    printf("Width of bitree is:%d",Width(BT));
    fclose(fp);
}
int Empty(BTREE *BT)
{
    if(BT==NULL)
        return 1;
    else
        return 0;
}
// BTREE *Lchild(BTREE *BT)
// {
//     if(BT->lchild!=NULL)
//         return BT->lchild;
//     else
//         return NULL;
// }
// BTREE *Rchild(BTREE *BT)
// {
//     if(BT->rchild!=NULL)
//         return BT->rchild;
//     else
//         return NULL;
// }
void CreateBT(BTREE * &BT)
{
    int num;
    scanf("%d",&num);
    if(num==-1) BT=NULL;
    else
    {
        BT=(BTREE *)malloc(sizeof(BTREE));
        BT->data=num;
        //Display(BT);
        CreateBT(BT->lchild);
        CreateBT(BT->rchild);
    }
}
void PreOrder(BTREE *BT,FILE *fp)
{
    if(!Empty(BT))
    {
        Display(BT);
        WriteFile(BT,fp);
        PreOrder(BT->lchild,fp);
        PreOrder(BT->rchild,fp);
    }
}
void NPreOrder(BTREE *BT,FILE *fp)
{
    printf("NPreOrder:");
    fprintf(fp,"NPreOrder:");
    BTREE *T=BT;
    STACK S;
    MakeNull(S);
    while(!Empty(S)||!Empty(T))
    {
        printf("%d ",T->data);
        fprintf(fp,"%d ",T->data);
        Push(T,S);
        T=T->lchild;
        while(Empty(T)&&!Empty(S))
        {
            T=Top(S);
            Pop(S);
            T=T->rchild;
        }
    }
    printf("\n");
    fprintf(fp,"\n");
}
void InOrder(BTREE *BT,FILE *fp)
{
    if(!Empty(BT))
    {
        InOrder(BT->lchild,fp);
        Display(BT);
        WriteFile(BT,fp);
        InOrder(BT->rchild,fp);
    }
}
void NInOrder(BTREE *BT,FILE *fp)
{
    printf("NInOrder:");
    fprintf(fp,"NInOrder:");
    BTREE *T=BT;
    STACK S;
    MakeNull(S);
    while(!Empty(T)||!Empty(S))
    {
        if(!Empty(T))
        {
            Push(T,S);
            T=T->lchild;
        }
        else
        {
            T=Top(S);
            Pop(S);
            printf("%d ",T->data);
            fprintf(fp,"%d ",T->data);
            T=T->rchild;
        }
        
    }
    printf("\n");
    fprintf(fp,"\n");
}
void PostOrder(BTREE *BT,FILE *fp)
{
    if(!Empty(BT))
    {
        PostOrder(BT->lchild,fp);
        PostOrder(BT->rchild,fp);
        Display(BT);
        WriteFile(BT,fp);
    }
}
void NPostOrder(BTREE *BT,FILE *fp)
{
    printf("NPostOrder:");
    fprintf(fp,"NPostOrder:");
    BTREE *T=BT;
    STACK S;
    int flag[MAX];
    MakeNull(S);
    while(!Empty(S)||!Empty(T))
    {
        if(!Empty(T))
        {
            Push(T,S);
            flag[S.top]=1;
            T=T->lchild;
        }
        else
        {
            if(flag[S.top]==1)
            {
                T=Top(S);
                flag[S.top]=2;
                T=T->rchild;
            }
            else
            {
                T=Top(S);
                printf("%d ",T->data);
                fprintf(fp,"%d ",T->data);
                Pop(S);
                T=NULL;
            }          
        }       
    }
    printf("\n");
    fprintf(fp,"\n");
}
void Display(BTREE *BT)
{
    printf("%d ",BT->data);
}
void WriteFile(BTREE *BT,FILE *fp)
{
    fprintf(fp,"%d ",BT->data);
}
void MakeNull(STACK &S)
{
    S.top=-1;
}
int Empty(STACK S)
{
    if(S.top<0)
        return 1;
    else
        return 0;
}
BTREE * Top(STACK S)
{
    if(Empty(S))
    {
        printf("Stack is empty!\n");
        return NULL;
    }
    else
    {
        return S.element[S.top];
    }
}
void Pop(STACK &S)
{
    if(Empty(S))
    {
        printf("Stack is empty!\n");
        return;
    }
    else
    {
        S.top=S.top-1;
    }
    
}
void Push(BTREE *BT,STACK &S)
{
    if(S.top==MAX-1)
    {
        printf("Stack is full!\n");
        return;
    }
    else
    {
        S.top=S.top+1;
        S.element[S.top]=BT;
    }
    
}
void MakeNull(QUEUE &Q)
{
    Q.front=(LINK *)malloc(sizeof(LINK));
    Q.front->next=NULL;
    Q.rear=Q.front;
}
int Empty(QUEUE Q)
{
    if(Q.front==Q.rear)
        return 1;
    else
        return 0;
}
BTREE *Front(QUEUE Q)
{
    if(Q.front->next)
        return Q.front->next->BT;
    else
    {
        printf("Queue is empty!\n");
        return NULL;
    }
}
void EnQueue(BTREE *BT,QUEUE &Q)
{
    Q.rear->next=(LINK *)malloc(sizeof(LINK));
    Q.rear=Q.rear->next;
    Q.rear->BT=BT;
    Q.rear->next=NULL;
}
void DeQueue(QUEUE &Q)
{
    if(Empty(Q))
    {
        printf("Queue is empty!\n");
        return;
    }
    else
    {
        LINK *temp=Q.front->next;
        Q.front->next=temp->next;
        free(temp);
        if(Q.front->next==NULL)
        {
            Q.rear=Q.front;
        }
    }
    
}
void LevelOrder(BTREE *BT,FILE *fp)
{
    BTREE *T=BT;
    QUEUE Q;
    MakeNull(Q);
    printf("LevelOrder:");
    fprintf(fp,"LevelOrder:");
    if(!Empty(T))
        EnQueue(T,Q);
    while(!Empty(Q))
    {
        T=Front(Q);
        DeQueue(Q);
        printf("%d ",T->data);
        fprintf(fp,"%d ",T->data);
        if(T->lchild)
            EnQueue(T->lchild,Q);
        if(T->rchild)
            EnQueue(T->rchild,Q);
    }
    printf("\n");
    fprintf(fp,"\n");
}
int CompleteBitree(BTREE *BT)
{
    QUEUE Q;
    MakeNull(Q);
    STACK S;
    MakeNull(S);
    BTREE *T=BT;
    if(T)
        EnQueue(T,Q);
    while(!Empty(Q))
    {
        T=Front(Q);
        DeQueue(Q);
        Push(T,S);
        if(T)
        {
            EnQueue(T->lchild,Q);
            EnQueue(T->rchild,Q);
        }
    }
    BTREE *temp;
    while(1)
    {
        temp=Top(S);
        Pop(S);
        if(temp)
            break;
    }
    while(1)
    {
        temp=Top(S);
        Pop(S);
        if(!temp)
            return 0;
    }
    return 1;
}
int Width(BTREE *BT)
{
    BTREE *T=BT;
    BTREE *queue[MAX];
    int front,rear,last;
    int temp_width=0,width=0;
    front=rear=last=0;
    if(!T)
        return 0;
    queue[rear++]=T;
    while(front!=rear)
    {
        T=queue[front++];
        temp_width++;
        if(T->lchild)
            queue[rear++]=T->lchild;
        if(T->rchild)
            queue[rear++]=T->rchild;
        if(front>=last)
        {
            last=rear;
            if(temp_width>width)
                width=temp_width;
            temp_width=0;
        }
    }
    return width;
}