重建二叉树

问题描述：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

函数接口： TreeNode* reConstructBinaryTree(vector pre,vector vin)

注意：不一定非要根据接口去写，自己能实现算法就可以了

解题方法

1.因为前序遍历的顺序就是按照根左右来创建的，所以参考前序遍历的顺序可以按照顺序来创建根结点，因为中序遍历的顺序是左根右，所以参考中序遍历的方法可以确定根节点的左子树和右子数，然后递归先创建左子树，然后创建右子树。

举个例子：

比如题中给出的数据

前序：1 2 4 7 3 5 6 8

中序：4 7 2 1 5 3 8 6

1.根据前序顺序首先根节点为1，所以在中序中找到1结点所在的位置，这个时候1结点左边的4 7 2 为根节点的左子树，右边的5 3 8 6为跟结点的右子数

2.根据前序根节点为2.找到中序中的2的位置，现在2的左边的4 7为2的左子树，因为1为根节点所以2没有右子数，

3.根据前序根节点为4，找到中序中4的位置。因为4的左边没有元素，所以4没有左子树，4的右边为7.所以4的右子数为7，这个时候整个树的左子树就出来了，如下图



下面开始创建根节点1的右子数

5.前序三为根节点，在中序中找到3的位置，所以5是3的左子树，8 6 是三的右子树

6.创建根节点5，5没有左右子树

7.创建根节点 6，在中序中找到6的位置，所以8是6的左子树，至此整个树就创建完成了。如下图



下面给出算法代码1：

PNode _reConstructBinaryTree(vector<int> pre, vector<int> vin)//重建二叉树的接口
{
if (pre.empty()||vin.empty())
return NULL;
int data = pre.front();
int n = vin.size();
int lenth = 0;
int index = 0;
PNode cur = new Node(data);//创建根节点
//下面开始在中序遍历中找根结点的左子树和右子数
for (int i = 0; i < n; i++)
{
if (vin[i] == data)
{
index = i;//找到右子树中对应的位置
lenth = n - i - 1;//记录中序遍历右子树的起点位置
break;
}
}
vector<int> preleft(pre.begin() + 1, pre.begin() + index+1);//记录左子树的前序遍历的顺序
vector<int> vinleft(vin.begin(), vin.begin() + index);//记录左子树中序遍历的顺序
vector<int> preright(pre.begin() +index+1, pre.begin()+lenth+index+1);//记录右子数的前序遍历顺序
vector<int> vinright(vin.begin() +index+1, vin.begin() + lenth+index+1);//记录右子树的中序遍历顺序
cur->Lchild = _reConstructBinaryTree(preleft, vinleft);
cur->Rchild = _reConstructBinaryTree(preright, vinright);
return cur;
}

算法代码2：

PNode  _ConstructBinTree(int *preOrder, int *inOrder, int length)//重建二叉树
{
if (NULL == preOrder || NULL == inOrder || length <= 0)
return NULL;
int data = preOrder[0];
PNode cur = new Node(data);
int index = 0;
int lenth = 0;
for (int i = 0; i < length; i++)//根据中序找到根节点的左右子树
{
if (data == inOrder[i])
{
index = i;//根节点在中序中的位置
lenth = length - i -1;
break;
}
}
int *preleft = preOrder + 1;//记录左子树前序
int *inleft = inOrder;//记录左子树中序
int *preright = preOrder + index + 1;//记录右子树前序
int *inright = inOrder + index + 1;//记录右字树中序
cur->Lchild = _ConstructBinTree(preleft, inleft, index);//创建左子树
cur->Rchild = _ConstructBinTree(preright, inright, lenth);//创建右子数
return cur;
}

下面给出完整代码和测试结果：

#include<iostream>
#include<vector>
using namespace std;
template<class T>
struct BinTreeNode//二叉树的结点
{
T _data;
BinTreeNode<T> *Lchild;
BinTreeNode<T> *Rchild;
BinTreeNode(T& data)
:_data(data)
, Lchild(NULL)
, Rchild(NULL){}
};
template<class T>
class TreeNode
{
typedef BinTreeNode<T> *PNode;
typedef BinTreeNode<T> Node;
public:
PNode head;
TreeNode()
:head(NULL)
{}

void reConstructBinaryTree(vector<int> pre, vector<int> vin)//调用重建二叉树的函数
{
head = _reConstructBinaryTree(pre, vin);
}
void ConstructBinTree(int *preOrder, int *inOrder, int length)
{
head = _ConstructBinTree(preOrder, inOrder, length);
}
private:
PNode _reConstructBinaryTree(vector<int> pre, vector<int> vin)//重建二叉树的接口
{
if (pre.empty()||vin.empty())
return NULL;
int data = pre.front();
int n = vin.size();
int lenth = 0;
int index = 0;
PNode cur = new Node(data);//创建根节点
//下面开始在中序遍历中找根结点的左子树和右子数
for (int i = 0; i < n; i++)
{
if (vin[i] == data)
{
index = i;//找到右子树中对应的位置
lenth = n - i - 1;//记录中序遍历右子树的起点位置
break;
}
}
vector<int> preleft(pre.begin() + 1, pre.begin() + index+1);//记录左子树的前序遍历的顺序
vector<int> vinleft(vin.begin(), vin.begin() + index);//记录左子树中序遍历的顺序
vector<int> preright(pre.begin() +index+1, pre.begin()+lenth+index+1);//记录右子数的前序遍历顺序
vector<int> vinright(vin.begin() +index+1, vin.begin() + lenth+index+1);//记录右子树的中序遍历顺序
cur->Lchild = _reConstructBinaryTree(preleft, vinleft);
cur->Rchild = _reConstructBinaryTree(preright, vinright);
return cur;
}
PNode  _ConstructBinTree(int *preOrder, int *inOrder, int length)//重建二叉树
{
if (NULL == preOrder || NULL == inOrder || length <= 0)
return NULL;
int data = preOrder[0];
PNode cur = new Node(data);
int index = 0;
int lenth = 0;
for (int i = 0; i < length; i++)//根据中序找到根节点的左右子树
{
if (data == inOrder[i])
{
index = i;//根节点在中序中的位置
lenth = length - i -1;
break;
}
}
int *preleft = preOrder + 1;//记录左子树前序
int *inleft = inOrder;//记录左子树中序
int *preright = preOrder + index + 1;//记录右子树前序
int *inright = inOrder + index + 1;//记录右字树中序
cur->Lchild = _ConstructBinTree(preleft, inleft, index);//创建左子树
cur->Rchild = _ConstructBinTree(preright, inright, lenth);//创建右子数
return cur;
}
};

int main()
{

vector<int> pre = { 1, 2, 4, 7, 3, 5, 6, 8 };
vector<int> vin = { 4, 7, 2, 1, 5, 3, 8, 6 };
TreeNode<int> s1;
TreeNode<int> s2;
int pree[] = { 1, 2, 4, 7, 3, 5, 6, 8 };
int vinn[] = { 4, 7, 2, 1, 5, 3, 8, 6 };
s1.reConstructBinaryTree(pre, vin);
s2.ConstructBinTree(pree, vinn, 8);
system("pause");
return 0;
}

结果如下：



这里只给出了s1的结果指向图，能做到这个题的应该懂这个图，这里就不多说了（直接去监视里面看就可以了，不懂的自己摸索），s2的自己去看看吧，两个结果是一样的，完整的创建了整个二叉树！