中序层序建立二叉树

思路：以结构体数组存储中序、层序数组信息。层序结构体数组信息包括数据元素、该数据元素在中序数组中的位置；中序数组信息包括数据元素、父母位置、左右孩子指针。建立标记数组（bool型），中序数组中，按层序数组中数据位置并以数组界限和标记元素界限为界先后查找父母，查找后的元素被标记。按照中序数组中父母信息建立二叉树即可。

#include <iostream>

#include <stdlib.h>

#include <stdio.h>

 //存储层序数组结构体

struct LevNode

{

    int lev;

    int locin;

};

//存储中序数组结构体

struct InNode

{

    int in;

    int parent;

    InNode *lchild;

    InNode *rchild;

};

 

int search(int lev, InNode in[], int n)

{

    int i;

    for(i = 0; i < n; i++)

    {

        if(lev == in[i].in)

        {

            break;

        }

    }

    return i;

}

 

void InitLev(LevNode lev[], InNode in[], int n)

{

    int k, i = 0;

    while(i < n)

    {

        k = search(lev[i].lev, in, n);

        if(i == 0)

        {

            in[k].parent = -1;

        }

        lev[i].locin = k;

        i++;

    }

}

 

void InitIn(LevNode lev[], InNode in[], int n)

{

    int j = 0, t;

    bool *visit = (bool*)malloc(sizeof(bool) * n);

//建立标记数组

    for(int i = 0; i < n; i++)

    {

        visit[i] = false;

    }

    for(int i = 0; i < n; i++)

    {

        j = lev[i].locin;

        t = j;

        visit[j] = true;

        j--;

//按照标记数组界限与数组本身界限查找父母位置

        while(j >= 0&&visit[j] == false)

        {

            in[j].parent = lev[i].locin;

            j--;

        }

        t++;

        while(t < n&&visit[t] == false)

        {

            in[t].parent = lev[i].locin;

            t++;

        }

    }

    printf("lev:/n");

    for(int i = 0; i < n; i++)

    {

        printf("%d %d/n", lev[i].lev, lev[i].locin);

    }

    printf("in:/n");

    for(int i = 0; i < n; i++)

    {

        printf("%d %d/n", in[i].in, in[i].parent);

    }

}

 

void CrtBT(LevNode lev[], InNode in[], int n, InNode**T)

{

    int i, t;

    InNode *p = in;

    for(i = 0; i < n; i++)

    {

        T[i] = p;

        p++;

    }

    for(i = 0; i < n; i++)

    {

        if(in[i].parent == -1)

        {

            ;

        }

        else if(in[i].parent > i)

        {

            t = in[i].parent;

            T[t]->lchild = T[i];

        }

        else if(in[i].parent < i)

        {

            t = in[i].parent;

            T[t]->rchild = T[i];

        }

    }

}

 

void PreOrderTraverse(InNode*T)

{

    if(T != NULL)

    {

        printf("%d ", T->in);

        PreOrderTraverse(T->lchild);

        PreOrderTraverse(T->rchild);

    }

}

 

void InOrderTraverse(InNode *T)

{

    if(T != NULL)

    {

        InOrderTraverse(T->lchild);

        InOrderTraverse(T->rchild);

        printf("%d ", T->in);

    }

}

 

int main()

{

    int length, k;

    scanf("%d", &length);

 

    LevNode *lev = (LevNode*)malloc(sizeof(LevNode)*length);

    InNode *in = (InNode*)malloc(sizeof(InNode)*length);

 

    for(int i = 0; i < length; i++)

    {

        scanf("%d", &lev[i].lev);

    }

 

    for(int i = 0; i < length; i++)

    {

        scanf("%d", &in[i].in);

    }

 

    InitLev(lev, in, length);

    InitIn(lev, in, length);

//建立二级指针，建立指针数组指向各个数据元素

    InNode**T=(InNode**)malloc(sizeof(InNode*)*length);

    CrtBT(lev, in, length, T);

//找到二叉树根节点遍历

    k = search(lev[0].lev, in, length);

    PreOrderTraverse(T[k]);

    printf("/n");

    InOrderTraverse(T[k]);

 

    return 0;

}