初学数据结构（二叉树的遍历和构造）

初学数据结构（二叉树的遍历和构造）

《数据结构教程》第6版 P243 实验题2,3

exp7-2

//
// Created by Snow on 2023/4/2.
//
#include<cstdio>
#include<cstdlib>
#define MaxSize 50
typedef char ElemType;
typedef struct node
{
    ElemType data;
    struct node *lchild;
    struct node *rchild;
}BTNode;
typedef struct
{
    BTNode *data[MaxSize];
    int top;
}SqStack;
typedef struct
{
    BTNode *data[MaxSize];
    int front,rear;
}SqQueue;

void InitStack(SqStack *&s)
{
    s=(SqStack*)malloc(sizeof(SqStack));
    s->top=-1;
}
void DestroyStack(SqStack *&s)
{
    free(s);
}
bool EmptyStack(SqStack *s)
{
    return s->top==-1;
}
bool Push(SqStack *&s,BTNode *e)
{
    if(s->top==MaxSize-1)
        return false;
    s->top++;
    s->data[s->top]=e;
    return true;
}
bool Pop(SqStack *&s,BTNode *&e)
{
    if(s->top==-1)
        return false;
    e=s->data[s->top];
    s->top--;
    return true;
}
bool GetTop(SqStack *s,BTNode *&e)
{
    if(s->top==-1)
        return false;
    e=s->data[s->top];
    return true;
}

void InitQueue(SqQueue *&q)
{
    q=(SqQueue *)malloc(sizeof(SqQueue));
    q->front=q->rear=0;
}
void DestroySqQueue(SqQueue *&q)
{
    free(q);
}
bool QueueEmpty(SqQueue *q)
{
    return(q->front==q->rear);
}
bool enQueue(SqQueue *&q,BTNode *e)
{
    if((q->rear+1)%MaxSize==q->front)
        return false;
    q->rear=(q->rear+1)%MaxSize;
    q->data[q->rear]=e;
    return true;
}
bool deQueue(SqQueue *&q,BTNode *&e)
{
    if(q->front==q->rear)
        return false;
    q->front=(q->front+1)%MaxSize;
    e=q->data[q->front];
    return true;
}

void CreateBTree(BTNode *&b,char const *str)
{
    BTNode *St[MaxSize],*p;
    int top=-1,k,j=0;
    b=nullptr;
    char ch=str[j];
    while(ch!='\0')
    {
        switch(ch)
        {
            case '(':top++;St[top]=p;k=1;break;
            case ',':k=2;break;
            case ')':top--;break;
            default:
                p=(BTNode*)malloc(sizeof(BTNode));
                p->data=ch;
                p->lchild=p->rchild=nullptr;
                if(b==nullptr)
                    b=p;
                else
                {
                    switch(k)
                    {
                        case 1:St[top]->lchild=p;break;
                        case 2:St[top]->rchild=p;break;
                    }
                }
        }
        j++;
        ch=str[j];
    }
}
void DestroyBTree(BTNode *&b)
{
    if(b!=nullptr)
    {
        DestroyBTree(b->lchild);
        DestroyBTree(b->rchild);
        free(b);
    }
}
//先序遍历递归算法
void PreOrder(BTNode *b)
{
    if(b!=nullptr)
    {
        printf("%c ",b->data);
        PreOrder(b->lchild);
        PreOrder(b->rchild);
    }
}
//中序遍历递归算法
void InOrder(BTNode *b)
{
    if(b!=nullptr)
    {
        InOrder(b->lchild);
        printf("%c ",b->data);
        InOrder(b->rchild);
    }
}
//后续遍历递归算法
void PostOrder(BTNode *b)
{
    if(b!=nullptr)
    {
        PostOrder(b->lchild);
        PostOrder(b->rchild);
        printf("%c ",b->data);
    }
}
//先序遍历非递归算法
void PreOrder1(BTNode *b)
{
    BTNode *p;
    SqStack *st;
    InitStack(st);
    if(b!=nullptr)
    {
        Push(st,b);
        while(!EmptyStack(st))
        {
            Pop(st,p);
            printf("%c ",p->data);
            if(p->rchild!=nullptr)
                Push(st,p->rchild);
            if(p->lchild!=nullptr)
                Push(st,p->lchild);
        }
        printf("\n");
    }
    DestroyStack(st);
}
//中序遍历非递归算法
void InOrder1(BTNode *b)
{
    BTNode *p;
    SqStack *st;
    InitStack(st);
    p=b;
    while(!EmptyStack(st)||p!=nullptr)
    {
        while(p!=nullptr)
        {
            Push(st,p);
            p=p->lchild;
        }
        if(!EmptyStack(st))
        {
            Pop(st,p);
            printf("%c ",p->data);
            p=p->rchild;
        }
    }
    printf("\n");
    DestroyStack(st);
}
//后序遍历非递归算法
void PostOrder1(BTNode *b)
{
    BTNode *p,*r;
    bool flag;
    SqStack *st;
    InitStack(st);
    p=b;
    do
    {
        while(p!=nullptr)
        {
            Push(st,p);
            p=p->lchild;
        }
        r=nullptr;
        flag=true;
        while(!EmptyStack(st)&&flag)
        {
            GetTop(st,p);
            if(p->rchild==r)
            {
                printf("%c ",p->data);
                Pop(st,p);
                r=p;
            }
            else
            {
                p=p->rchild;
                flag=false;
            }
        }
    }while(!EmptyStack(st));
    printf("\n");
    DestroyStack(st);
}
//层次遍历算法
void LevelOrder(BTNode *b)
{
    BTNode *p;
    SqQueue *qu;
    InitQueue(qu);
    enQueue(qu,b);
    while(!QueueEmpty(qu))
    {
        deQueue(qu,p);
        printf("%c ",p->data);
        if(p->lchild!=nullptr)
            enQueue(qu,p->lchild);
        if(p->rchild!=nullptr)
            enQueue(qu,p->rchild);
    }
    printf("\n");
    DestroySqQueue(qu);
}
int main()
{
    BTNode *b;
    CreateBTree(b, "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
    printf("先序遍历递归：");
    PreOrder(b);
    printf("\n");
    printf("先序遍历非递归：");
    PreOrder1(b);
    printf("中序遍历递归：");
    InOrder(b);
    printf("\n");
    printf("中序遍历非递归：");
    InOrder1(b);
    printf("后序遍历递归：");
    PostOrder(b);
    printf("\n");
    printf("后序遍历非递归：");
    PostOrder1(b);
    printf("层次序遍历：");
    LevelOrder(b);
    DestroyBTree(b);
}

exp7-3

//
// Created by Snow on 2023/4/3.
//
#include<cstdio>
#include<cstdlib>

typedef char ElemType;
typedef struct node
{
    ElemType data;
    struct node *lchild;
    struct node *rchild;
}BTNode;
void DestroyBTree(BTNode *&b)
{
    if(b!=nullptr)
    {
        DestroyBTree(b->lchild);
        DestroyBTree(b->rchild);
        free(b);
    }
}
void DispBTree(BTNode *b)
{
    if(b!=nullptr)
    {
        printf("%c",b->data);
        if(b->lchild!=nullptr||b->rchild!=nullptr)
        {
            printf("(");
            DispBTree(b->lchild);
            if(b->rchild!=nullptr)
                printf(",");
            DispBTree(b->rchild);
            printf(")");
        }
    }
}
//先序序列和中序序列
BTNode *CreateBT1(char *pre,char *in,int n)
{
    BTNode *b;
    char *p;
    int k;
    if(n<=0)
        return nullptr;
    b=(BTNode*)malloc(sizeof(BTNode));
    b->data=*pre;
    for(p=in;p<in+n;p++)
        if(*p==*pre)
            break;
    k=p-in;
    b->lchild=CreateBT1(pre+1,in,k);
    b->rchild=CreateBT1(pre+k+1,p+1,n-k-1);
    return b;
}
//后序序列和中序序列
BTNode *CreateBT2(char *post,char *in,int n)
{
    BTNode *b;
    char r,*p;
    int k;
    if(n<=0)
        return nullptr;
    r=*(post+n-1);
    b=(BTNode*)malloc(sizeof(BTNode));
    b->data=r;
    for(p=in;p<in+n;p++)
        if(*p==r)
            break;
    k=p-in;
    b->lchild=CreateBT2(post,in,k);
    b->rchild=CreateBT2(post+k,p+1,n-k-1);
    return b;
}
void Disp(BTNode *b,int k=10)
{
    if(b!=nullptr)
    {
        printf("%c ",b->data);
        for(int i=1;i<k;i++)
            printf("#");
        printf("\n");
        k--;
        if(b->lchild!=nullptr)
            Disp(b->lchild,k);
        if(b->rchild!=nullptr)
            Disp(b->rchild,k);
    }
}
int main()
{
    BTNode *b1,*b2;
    char pre[]="ABDEHJKLMNCFGI";
    char in[]="DBJHLKMNEAFCGI";
    char post[]="DJLNMKHEBFIGCA";
    b1=CreateBT1(pre,in,14);
    b2=CreateBT2(post,in,14);
    printf("先序序列和中序序列构造的二叉树b1：");
    DispBTree(b1);
    printf("\n");
    printf("后序序列和中序序列构造的二叉树b1：");
    DispBTree(b2);
    printf("\n");
    printf("凹入表示法输出：\n");
    Disp(b1);
    DestroyBTree(b1);
    DestroyBTree(b2);
}