由层序遍历序列和中序遍历序列确定二叉树

如何通过层序遍历序列和中序遍历序列来确定一棵二叉树？

• 根据层序遍历序列第一个结点确定根结点；
• 根据根结点在中序遍历序列中分割出左右子树的中序序列；
• 根据分割出的左右子树的中序序列从层序序列中提取出对应的左右子树的层序序列；
• 对左子树和右子树分别递归使用相同的方式继续分解；

要点：根据分割出的左右子树的中序序列从层序序列中提取出对应的左右子树的层序序列，分别构建出新的左右子树的层序序列和中序序列；

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct node
{
    char data;
    struct node *lt, *rt;
};

// 前序遍历
void preorder(struct node *root)
{
    if(root)
    {
        printf("%c", root->data);       
        preorder(root->lt);
        preorder(root->rt);
    }
}

// 中序遍历
void midorder(struct node *root)
{
    if(root)
    {
        midorder(root->lt);
        printf("%c", root->data);          
        midorder(root->rt);
    }
}

// 后序遍历
void postorder(struct node *root)
{
    if(root)
    {
        postorder(root->lt);
        postorder(root->rt);
        printf("%c", root->data);
    }
}

// 层序遍历
void levelorder( struct node *root )
{
    struct node *queue[100];
    struct node *pt;
    int head;
    int tail;

    head = 0;
    tail = 0;

    queue[tail++] = root;
    while( tail != head )
    {
        pt = queue[head++];
        printf("%c", pt->data);
        if( pt->lt != NULL )
        {
            queue[tail++] = pt->lt;
        }

        if( pt->rt != NULL )
        {
            queue[tail++] = pt->rt;
        }
    }
}

// 由先序序列和中序序列建立二叉树
struct node *create_by_pre_and_mid(int n, char *pre, char *mid)
{
    struct node *root;
    int i;

    if(n==0)
        return NULL;

    root=(struct node *)malloc(sizeof(struct node));
    root->data=pre[0];

    for(i=0;i<n;i++) // 寻找左右子树的元素
        if(pre[0]==mid[i])
            break;

    root->lt = create_by_pre_and_mid(i, pre+1, mid); // 建立左子树
    root->rt = create_by_pre_and_mid(n-i-1, pre+i+1, mid+i+1); // 建立右子树

    return root;
}

// 由后序序列和中序序列建立二叉树
struct node *create_by_post_and_mid(int n, char *post, char *mid)
{
    struct node *root;
    int i;

    if(n==0)
        return NULL;

    root=(struct node *)malloc(sizeof(struct node));
    root->data=post[n-1];

    for(i=0;i<n;i++) // 寻找左右子树的元素
        if(post[n-1]==mid[i])
            break;

    root->lt = create_by_post_and_mid(i, post, mid); // 建立左子树
    root->rt = create_by_post_and_mid(n-i-1, post+i, mid+i+1); // 建立右子树

    return root;
}

// 由层序序列和中序序列建立二叉树
struct node *create_by_level_and_mid(int n, char *level, char *mid)
{
    struct node *root;
    char left[20];
    char right[20];
    int i, j, k;
    int l, r;
    int lcnt, rcnt;

    lcnt = 0;
    rcnt = 0;

    if( n == 0 )
        return NULL;

    root = (struct node *)malloc(sizeof(struct node));
    root->data = level[0];

    // 找到根节点
    for( i = 0; i < n; i++ )
        if( level[0] == mid[i] )
            break;
    
    // 划分左右子树
    for( k = 0; k < n; k++ )
    {
        for( l = 0; l < i; l++ )
        {
            if( mid[l] == level[k] )
            {

                left[lcnt++] = level[k];
            }
        }
        for( r = 0; r < n-i-1; r++ )
        {
            if( mid[r+i+1] == level[k] )
            {
                right[rcnt++] = level[k];
            }
        }
    }

    root->lt = create_by_level_and_mid( lcnt, left, mid );
    root->rt = create_by_level_and_mid( rcnt, right, mid+i+1 );

    return root;
}

/**
 *
 *           A
 *          / 
 *         B   C
 *        /  /   
 *       D  E G   H
 *         /       
 *        F         I
 **/
int main( void )
{
    struct node *root=NULL;
    int len;
    char *post = "DFEBGIHCA";
    char *pre = "ABDEFCGHI";
    char *mid = "DBFEAGCHI";
    char *level = "ABCDEGHFI";

    len = strlen(mid);

    //root = create_by_pre_and_mid(len, pre, mid);
    //root = create_by_post_and_mid(len, post, mid);
    root = create_by_level_and_mid( len, level, mid );

    printf("
preorder:
");
    preorder(root);

    printf("
midorder:
");
    midorder(root);

    printf("
postorder:
");
    postorder(root);

    printf("
levelorder:
");
    levelorder( root );

    printf("
");

    system("pause");
    return 0;
}