【7】二叉树的重建

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/dai_wen/article/details/79948798

面试题7:重建二叉树

1、题目
2、分析
3、测试代码
4、测试结果如下
- 给出二叉树的前序遍历和中序遍历,或者后序遍历和中序遍历就可以构建出该二叉树;
- 若仅仅给出前序遍历和后序遍历无法构建出一颗二叉树

1、题目:

输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。
假设输入的前序遍历和中序遍历的结果中都不含重复的数字;

例如:
输入前序遍历序列{1, 2, 4, 7, 3, 5, 6, 8},
它的中序遍历序列{4, 7, 2, 1, 5, 3, 8, 6},
则重建出如下所示:
这里写图片描述

2、分析:

根据前序遍历序列我们可以得出,前序中第一个数字(1) 就是该树的根节点,那么,在中序遍历中,(1)为中间节点的位置,在(1)前面的所有数字为该树的左子树中的所有节点(4,7,2),在(1)右面的所有数字,为右子树的所有节点(5,3,8,6);再根据同样的方法寻求左右子树的节点;在前序遍历中(1)的左孩子为(2)那么,在中序遍历中,(2)的前面(4,7)为它左子树的节点,(2)的后面没有数字,所以(2)没有右孩子;在前序遍历中,(2)的左孩子为(4),在中序遍历中,(4)的前面没有数字,代表(4)没有左孩子,(4)的后面为(7),则(7)为(4)的右孩子,到这里,根节点(1)的左子树就全部构建完成,其右子树构建跟左子树的方式一样,这里不再赘述;

3、测试代码:

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
 struct BinTreeNode
{
    int _value;
    BinTreeNode *_pLeft;
    BinTreeNode *_pRight;
};
//二叉树的基本操作
BinTreeNode* BuyBTNode(int data)//创建节点
{
    BinTreeNode* node = (BinTreeNode*)malloc(sizeof(BinTreeNode));
    node->_value = data;
    node->_pLeft = NULL;
    node->_pRight = NULL;
    return node;
}

void DestroyTree(BinTreeNode* root)//销毁二叉树
{
    if (root == NULL)
        return;
    DestroyTree(root->_pLeft);
    DestroyTree(root->_pRight);
    free(root);
}
//========================================================

BinTreeNode* constructcore( int*startpre, int* endpre, int*startin, int*endin )
{
    int rootvalue = startpre[0];
    BinTreeNode* root = new BinTreeNode();
    root->_value = rootvalue;
    root->_pLeft  = root->_pRight  = NULL;
    //只有根节点
    if(startpre == endpre )
    {
        if(startin == endin && *startpre == *startin)
        {
            return root;
        }
        else printf("无效的输入\n");
    }
    //在中序遍历中找到根节点的值
    int* rootin = startin;
    while(rootin <= endin && *rootin != rootvalue )
    {
        ++rootin;
    }
    if(rootin == endin &&*rootin!= rootvalue)
    {
        printf("无效的输入\n");
    }
    int leftlength = rootin - startin;
    int* leftPreEnd = startpre + leftlength;
    if(leftlength > 0)
    {
        //构建左子树
        root->_pLeft = constructcore(startpre+1,leftPreEnd,startin,rootin-1);
    }
    if(leftlength <( endpre -startpre) )
    {//构建右子树
        root->_pRight = constructcore(leftPreEnd+1,endpre,rootin+1,endin);
    }
    return root;
}


BinTreeNode* construct(int* pre,int* in , int length)
{
    if(pre == NULL || in == NULL||length <= 0)
    {
        return NULL;
    }
    return constructcore(pre, pre+length-1,in,in+length-1);
}

//=========================测试代码===========================
//************************************************************
//============================================================
void test(int* preorder,int* inorder,int length)
{
      printf("前序遍历为: ");
    for (int i = 0; i < length; ++i)
        printf("%d ", preorder[i]);
        printf("\n");

    printf("中序遍历为: ");
    for (int i = 0; i < length; ++i)
        printf("%d ", inorder[i]);
    printf("\n");
    BinTreeNode* root = construct(preorder, inorder, length);
    printf("\n");
    DestroyTree(root);
}
// 普通二叉树
//              1
//           /     \
//          2       3  
//         /       / \
//        4       5   6
//         \         /
//   
void Test1()
{
    const  int length = 8;
    int preorder[length] = { 1, 2, 4, 7, 3, 5, 6, 8 };
    int inorder[length] = { 4, 7, 2, 1, 5, 3, 8, 6 };
    test(preorder,inorder,length);
}
// 所有结点都没有右子结点
//            1
//           / 
//          2   
//         / 
//        3 
//       /
//      4
//     /
//    5
void Test2()
{
    const int length = 5;
    int preorder[length] = {1, 2, 3, 4, 5};
    int inorder[length] = {5, 4, 3, 2, 1};
    test(preorder,inorder,length);
}
// 所有结点都没有左子结点
//            1
//             \ 
//              2   
//               \ 
//                3 
//                 \
//                  4
//                   \
//                    5
void Test3()
{
    const int length = 5;
    int preorder[length] = {1, 2, 3, 4, 5};
    int inorder[length] = {1, 2, 3, 4, 5};
    test(preorder,inorder,length);
}
// 树中只有一个结点
void Test4()
{
    const int length = 1;
    int preorder[length] = {1};
    int inorder[length] = {1};

    test(preorder,inorder,length);
}

// 完全二叉树
//              1
//           /     \
//          2       3  
//         / \     / \
//        4   5   6   7
void Test5()
{
    const int length = 7;
    int preorder[length] = {1, 2, 4, 5, 3, 6, 7};
    int inorder[length] = {4, 2, 5, 1, 6, 3, 7};

    test(preorder,inorder,length);
}

int main()
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();

    return 0;
}

4、测试结果如下:

这里写图片描述

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页