由遍历序列构造二叉树

/**
*    实验题目:
*        由遍历序列构造二叉树
*    实验目的:
*        领会二叉树的构造过程以及构造二叉树的算法设计
*    实验内容:
*        设计程序，实现由先序序列和中序序列以及由中序序列和后序序列构造
*    一颗二叉树的功能(二叉树中每个结点值为单个字符)。要求以括号表示法和
*    凹入表示法输出该二叉树。并用先序遍历序列"A B D E H J K L M N C F G I"
*    和中序遍历序列"D B J H L K M N E A F C G I"以及中序遍历序列"D B J H
*    L K M N E A F C G I"和后序遍历序列"D J L N M K H E B F I G C A"进行验证。
*/

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>

#define MAX_SIZE 100
#define MAX_WIDTH 40
#define WIDTH 4

typedef char ElemType;
typedef struct node
{
    ElemType data; // 数据元素
    struct node *lchild; // 指向左孩子结点
    struct node *rchild; // 指向右孩子结点
}BTNode; // 声明二叉链结点类型

/*-------------由括号表示串str创建二叉链b-----------------*/
static void create_btree(BTNode *&b, char *str) // 创建二叉树(形参b:指针的引用)
{
    BTNode *p;
    BTNode *St[MAX_SIZE]; // 定义一个顺序栈
    int k;
    int j = 0;
    int top = -1; // 栈顶指针初始化
    char ch;

    b = NULL; // 建立的二叉树初始时为空
    ch = str[j]; // 取第一个字符
    while(ch != '\0') // str未扫描完时循环
    {
        switch(ch)
        {
        case '(': // 开始处理左子树
            top++;
            St[top] = p;
            k = 1;
            break;
        case ')': // 子树处理完毕
            top--;
            break;
        case ',': // 开始处理右子树
            k = 2;
            break;
        default:
            p = (BTNode *)malloc(sizeof(BTNode)); // 动态分配结点p的存储空间
            p->data = ch;
            p->lchild = p->rchild = NULL;
            if(b == NULL) // 若b为空,p置为二叉树的根结点
                b = p;
            else // 已建立二叉树根结点
            {
                switch(k)
                {
                case 1:
                    St[top]->lchild = p;
                    break;
                case 2:
                    St[top]->rchild = p;
                    break;
                }
            }
            break;
        }
        // 取下一个字符
        j++;
        ch = str[j];
    }
}

/*--------------------------以括号表示法输出二叉树b----------------------*/
// "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))"
static void disp_btree(BTNode *b)
{
    if(b != NULL)
    {
        printf("%c", b->data);
        if(b->lchild != NULL || b->rchild != NULL)
        {
            printf("("); // 有孩子结点时才输出(
            disp_btree(b->lchild); // 递归处理左子树
            if(b->rchild != NULL) // 有右孩子结点时才输出,
                printf(",");
            disp_btree(b->rchild); // 递归处理右子树
            printf(")"); // 有孩子结点时才输出)
        }
    }
}

/*--------------------------释放二叉树b的所有结点----------------------*/
static void destroy_btree(BTNode *&b) // 销毁二叉树(形参b:指针的引用)
{
    if(b != NULL)
    {
        destroy_btree(b->lchild);
        destroy_btree(b->rchild);
        free(b);
    }
}

/*--------------------------由先序和中序遍历序列构造二叉树----------------------*/
// pre:ABDEHJKLMNCFGI
// in:DBJHLKMNEAFCGI
// A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))
static BTNode *create_btree_by_pre_in(char *pre, char *in, int n)
{
    BTNode *b;
    char *p;
    int k;

    if(n <= 0)
        return NULL;

    b = (BTNode *)malloc(sizeof(BTNode)); // 创建二叉树结点b
    b->data = *pre;
    for(p = in; p < in + n; p++) // 在中序序列in中查找等于*pre字符的位置
    {
        if(*p == *pre) // pre指向根结点
        {
            break; // 在中序序列in中找到后退出循环
        }
    }
    k = p - in; // 确定根结点在中序序列in中的位置
    b->lchild = create_btree_by_pre_in(pre + 1, in, k); // 递归构造左子树
    b->rchild = create_btree_by_pre_in(pre + k + 1, p + 1, n - k - 1); // 递归构造右子树

    return b;
}

/*--------------------------以凹入表示法输出一颗二叉树b----------------------*/
static void disp_btree1(BTNode *b)
{
    BTNode *p;
    BTNode *st[MAX_SIZE];
    int top = -1;
    int i;
    int n;
    int level[MAX_SIZE][2];
    char type; // 存放左右孩子标记

    if(b != NULL)
    {
        top++;
        st[top] = b; // 根结点进栈
        level[top][0] = WIDTH;
        level[top][1] = 2; // 2表示根
        while(top > -1) // 栈不空时循环
        {
            p = st[top]; // 取栈顶结点,并凹入显示该结点值
            n = level[top][0]; // 取根结点的显示场宽,即左边的空格个数
            switch(level[top][1])
            {
            case 0: // 左结点之后输出(L)
                type = 'L';
                break;
            case 1: // 右结点之后输出(R)
                type = 'R';
                break;
            case 2: // 根结点之后输出(B)
                type = 'B';
                break;
            }
            for(i = 1; i < n; i++) // 其中n为显示场宽,字符以右对齐显示
                printf(" ");
            printf("%c(%c)", p->data, type);
            for(i = n + 1; i <= MAX_WIDTH; i += 2)
                printf("--");
            printf("\n");
            top--; // 出栈
            if(p->rchild != NULL)
            {
                top++;
                st[top] = p->rchild; // 右孩子进栈
                level[top][1] = 1; // 1表示是右子树
                level[top][0] = n + WIDTH; // 显示场宽增WIDTH
            }
            if(p->lchild != NULL)
            {
                top++;
                st[top] = p->lchild; // 左孩子进栈
                level[top][1] = 0; // 0表示是左子树
                level[top][0] = n + WIDTH; // 显示场宽增WIDTH
            }
        }
    }
}

/*--------------------------由中序和后序遍历序列构造二叉树----------------------*/
// post:DJLNMKHEBFIGCA
// in:DBJHLKMNEAFCGI
// A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))
static BTNode *create_btree_by_post_in(char *post, char *in, int n)
{
    BTNode *b;
    char root;
    char *p;
    int k;

    if(n <= 0)
        return NULL;

    root = *(post + n - 1); // 取根结点值
    b = (BTNode *)malloc(sizeof(BTNode)); // 创建二叉树结点b(动态分配存储空间)
    b->data = root;
    for(p = in; p < in + n; p++) // 在中序序列in中查找根结点
    {
        if(*p == root)
        {
            break;
        }
    }
    k = p - in; // k为根结点在in中的下标
    b->lchild = create_btree_by_post_in(post, in, k); // 递归构造左子树
    b->rchild = create_btree_by_post_in(post + k, p + 1, n - k - 1); // 递归构造右子树

    return b;
}

int main(int argc, char *argv[])
{
    BTNode *b;
    ElemType pre[] = "ABDEHJKLMNCFGI";
    ElemType in[] = "DBJHLKMNEAFCGI";
    ElemType post[] = "DJLNMKHEBFIGCA";
    int n = 14; // 二叉树中共有14个结点

    b = create_btree_by_pre_in(pre, in, n);
    printf("先序序列:%s\n", pre);
    printf("中序序列:%s\n", in);
    printf("构造一颗二叉树b:\n");
    printf("  括号表示法:");
    disp_btree(b);
    printf("\n");
    printf("  凹入表示法:\n");
    disp_btree1(b);
    printf("\n\n");

    printf("中序序列:%s\n", in);
    printf("后序序列:%s\n", post);
    b = create_btree_by_post_in(post, in, n);
    printf("构造一颗二叉树b:\n");
    printf("  括号表示法:");
    disp_btree(b);
    printf("\n");
    printf("  凹入表示法:\n");
    disp_btree1(b);
    printf("\n");

    destroy_btree(b);

    return 0;
}

测试结果:

先序序列:ABDEHJKLMNCFGI
中序序列:DBJHLKMNEAFCGI
构造一颗二叉树b:
  括号表示法:A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))
  凹入表示法:
   A(B)------------------------------------
       B(L)--------------------------------
           D(L)----------------------------
           E(R)----------------------------
               H(L)------------------------
                   J(L)--------------------
                   K(R)--------------------
                       L(L)----------------
                       M(R)----------------
                           N(R)------------
       C(R)--------------------------------
           F(L)----------------------------
           G(R)----------------------------
               I(R)------------------------

中序序列:DBJHLKMNEAFCGI
后序序列:DJLNMKHEBFIGCA
构造一颗二叉树b:
  括号表示法:A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))
  凹入表示法:
   A(B)------------------------------------
       B(L)--------------------------------
           D(L)----------------------------
           E(R)----------------------------
               H(L)------------------------
                   J(L)--------------------
                   K(R)--------------------
                       L(L)----------------
                       M(R)----------------
                           N(R)------------
       C(R)--------------------------------
           F(L)----------------------------
           G(R)----------------------------
               I(R)------------------------