还原二叉树

#include <stdio.h>
#include <stdlib.h>
#include<string.h>

typedef struct node
{
    char data;
    struct node *lChild, *rChild;
} tNode,*tPointer;

void myStr(char main[],char sub[],int index,int length)
{
    int i = 0;
    while(i < length +1)
    {
        if(i < length)
        {
            sub[i] = main[index];
            index++;
        }
        else
        {
            sub[i] = '\0';
        }
        i++;
    }
}

//先序是father，中序是mother
void subMyFMStr(char father[],char mother[],char lFather[],char rFather[],char lMother[],char rMother[])
{
    int i = 0;
    while(i < strlen(mother))
    {
        if(father[0] == mother[i])
        {
            myStr(father,lFather,1,i);
            //printf("%s\n",lFather);
            myStr(father,rFather,i + 1,strlen(father) - i - 1);
            //printf("%s\n",rFather);
            myStr(mother,lMother,0,i);
            //printf("%s\n",lMother);
            myStr(mother,rMother,i + 1,strlen(mother) - i - 1);
            //printf("%s\n",rMother);
        }
        i++;
    }
}

//后序是father，中序是mother
void subMyAMStr(char father[],char mother[],char lFather[],char rFather[],char lMother[],char rMother[])
{
    int i = 0;
    while(i < strlen(mother))
    {
        if(father[strlen(father) - 1] == mother[i])
        {
            myStr(father,lFather,0,i);
            //printf("%s\n",lFather);
            myStr(father,rFather,i,strlen(father) - i - 1);
            //printf("%s\n",rFather);
            myStr(mother,lMother,0,i);
            //printf("%s\n",lMother);
            myStr(mother,rMother,i + 1,strlen(mother) - i - 1);
            //printf("%s\n",rMother);
        }
        i++;
    }
}

//递归先序、中序创建二叉树，没有#
tPointer frontMiddleTree(tPointer t,char frontStr[],char middleStr[])
{
    char lSubFront[100],rSubFront[100],lSubMiddle[100],rSubMiddle[100];

    if(strlen(frontStr) >= 1 && strlen(middleStr) >= 1)
    {
        t = (tPointer)malloc(sizeof(tNode));
        t -> data = frontStr[0];
        t -> lChild = NULL;
        t -> rChild = NULL;

        if(strlen(frontStr) > 1 && strlen(middleStr)  > 1)
        {
            subMyFMStr(frontStr,middleStr,lSubFront,rSubFront,lSubMiddle,rSubMiddle);

            t -> lChild = frontMiddleTree(t -> lChild,lSubFront,lSubMiddle);
            t -> rChild = frontMiddleTree(t -> rChild,rSubFront,rSubMiddle);
        }
    }
    return t;
}

//递归后序、中序创建二叉树，没有#
tPointer afterMiddleTree(tPointer t,char afterStr[],char middleStr[])
{
    char lSubAfter[100],rSubAfter[100],lSubMiddle[100],rSubMiddle[100];

    if(strlen(afterStr) >= 1 && strlen(middleStr) >= 1)
    {
        t = (tPointer)malloc(sizeof(tNode));
        t -> data = afterStr[strlen(afterStr)- 1];
        t -> lChild = NULL;
        t -> rChild = NULL;

        if(strlen(afterStr) > 1 && strlen(middleStr) > 1)
        {
            subMyAMStr(afterStr,middleStr,lSubAfter,rSubAfter,lSubMiddle,rSubMiddle);

            t -> lChild = afterMiddleTree(t -> lChild,lSubAfter,lSubMiddle);
            t -> rChild = afterMiddleTree(t -> rChild,rSubAfter,rSubMiddle);

        }
    }
    return t;
}

//递归先序遍历二叉树
void frontTree(tPointer t)
{
    if (t)
    {
        printf("%c",t -> data);
        frontTree(t -> lChild);
        frontTree(t -> rChild);
    }
}

//递归后续遍历二叉树
void afterTree(tPointer t)
{
    if (t)
    {
        afterTree(t -> lChild);
        afterTree(t -> rChild);
        printf("%c",t -> data);
    }
}

//递归删除二叉树
void destroyTree(tPointer t)
{
    if(t)
    {
        if(t -> lChild)destroyTree(t -> lChild);//删除左子树
        if(t -> rChild)destroyTree(t -> rChild);//删除右子树
        free(t);
        t = NULL;
    }
}

int main()
{
    char frontStr[100] = "";
    char middleStr[100] = {'\0'};
    char afterStr[100] = "";

    printf("输入先序序列\n");
    gets(frontStr);
    printf("输入中序序列\n");
    gets(middleStr);

    tPointer t1;
    t1 = frontMiddleTree(t1,frontStr,middleStr);
    printf("后序序列：");
    afterTree(t1);
    printf("\n");
    destroyTree(t1);

    printf("输入后序序列\n");
    gets(afterStr);
    printf("输入中序序列\n");
    gets(middleStr);

    tPointer t2;
    t2 = afterMiddleTree(t2,afterStr,middleStr);
    printf("先序序列：");
    frontTree(t2);
    printf("\n");
    destroyTree(t2);

    return 0;
}