剑指offer--据前序和中序遍历重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
分析：此时不由得想起前序遍历的顺序是根--左--右

 

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
using namespace std;
struct BTreeNode
{
    int _value;
    BTreeNode*_left;
    BTreeNode*_right;
};

//解法一
BTreeNode* RebuildCode(int * PreStart,int *PreEnd,int *InStart,int *InEnd);
BTreeNode* RebuildTree(int *PreOrder,int *InOrder,int len)
{
    //首先判断边界条件
    if(PreOrder == NULL || InOrder == NULL ||len <= 0)
    {
        return NULL;
    }
    else
    {
        return RebuildCode(PreOrder,PreOrder+len-1,InOrder,InOrder+len-1);
    }
}
BTreeNode* RebuildCode(int * PreStart,int *PreEnd,int *InStart,int *InEnd)
{
    BTreeNode *root = new BTreeNode();
    //新建节点root保存前序第一个节点为根结点
    root->_value = PreStart[0];
    root-> _left = NULL;
    root->_right  = NULL;
    if(InStart == InEnd && *InStart == *InEnd)
    {
        return root;
    }
    //据此节点找到中序遍历此节点的位置
    int *rootIn = InStart;
    while(*PreStart != *rootIn)
    {
        rootIn++;
    }
    //左子树的长度
    int leftlen = rootIn-InStart;
    //重建左子树
    if(leftlen > 0)
    {
        root->_left = RebuildCode( PreStart+1,PreStart+leftlen,InStart,InStart+leftlen-1);


    }
    //重建右子树
    if(InStart+leftlen < InEnd)
    {
        root->_right = RebuildCode( PreStart+leftlen+1,PreEnd,InStart+leftlen+1,InEnd);

    }
    return root;
}
//后序遍历输出二叉树序列
void PostOrder(BTreeNode *root)
{
    if(root->_left != NULL)
    {
        PostOrder(root->_left);
    }
     if(root->_right != NULL)
    {
        PostOrder(root->_right);
    }
    if(root != NULL)
    {
        cout<<root->_value<<" ";
    }
}
int main()
{
    int PreOrder[8] = {1,2,4,7,3,5,6,8};
    int  InOrder[8] = {4,7,2,1,5,3,8,6};
    BTreeNode *root = NULL;

    PostOrder(RebuildTree(PreOrder,InOrder,8));
    system("pause");
    return 0;
}

 

//解法二
void RebuildTree(int * PreOrder,int *InOrder,int len,BTreeNode ** root)
{
    if(PreOrder == NULL || InOrder == NULL)
    {
        return;
    }
    BTreeNode*tmp = new BTreeNode();
    tmp->_value = PreOrder[0];
    tmp->_left = NULL;
    tmp->_right = NULL;
    if( root == NULL)
    {
        *root = tmp;
    }
    if(len == 1)
    {
        return;
    }
    int *OriOrder = InOrder;
    int *LeftEnd = InOrder;
    int tmplen = 0;

    //找到左子树的结尾
    while(*PreOrder != *LeftEnd)
    {
        if(PreOrder == NULL || LeftEnd == NULL)
        {
            return;
        }
        tmplen++;
        if(tmplen>len)
        {
            break;
        }
        LeftEnd++;
    }
    //计算左子树的长度
    int leftlen = 0;
    leftlen = LeftEnd-OriOrder;
    //计算右子树的长度
    int rightlen = 0;
    rightlen = len-leftlen-1;
    //重建左子树
    if(leftlen > 0)
    {
         RebuildTree(PreOrder+1,InOrder,leftlen,&((*root)->_left));
    }

    //重建右子树
    if(rightlen < 0)
    {
        RebuildTree(PreOrder+leftlen+1,InOrder+leftlen+1,rightlen, &((*root)->_right));
    }

}

其实还可以优化，就是利用栈和队列来实现，相对来说较递归要好理解一些。
其实这还出现一些问题，倘若出现相同元素怎么处理，这就需要下去继续深究了