[c++]已知二叉树的前序遍历与中序遍历结果(二叉树中不含重复数字)，重构二叉树

比如说某二叉树

前序遍历结果：

1

2

4

7

3

5

6

8

中序遍历结果：

4

7

2

1

5

3

8

6

前序遍历就是先输出根节点，然后左节点，然后右节点

中序遍历就是先输出左节点，然后根节点，最后右节点

对于上面的二叉树我们可以这样分析：

1

2

4

7

3

5

6

8

4

7

2

1

5

3

8

6

其中绿色的为根结点，也就是1，

然后通过中序遍历结果，得到 1 左边的（粉红）为左子树，右边的（浅蓝）为右子树，

左子树跟右子树在前序遍历的结果中，我们能根据左子树跟右子树的大小划分开来，

然后就得到了一颗根节点为 2 ，另一颗跟节点为 3 的二叉树了，

如此递归下去就能得到一颗完整的二叉树。

以下为c++实现的代码：

基于gcc version 3.4.4 (cygming special, gdc 0.12, using dmd 0.125)

/*已知二叉树的前序、中序遍历，重建二叉树*/

#include <iostream>
#include <list>
#include <sstream>
using namespace std;
struct tree{
int m_nValue;
tree *l_tree;
tree *r_tree;
}*root;

/*重建二叉树的主函数，通过递归重建
*f_begin：前序遍历头结点
*f_end :  前序遍历末尾节点
*m_begin：中序遍历头结点
*m_end：  中序遍历末尾节点
*/
tree *rebuild_tree(list<int>::iterator f_begin,list<int>::iterator f_end,list<int>::iterator m_begin,list<int>::iterator m_end);

/*显示重建后的二叉树*/
void show_tree(tree *root);

/*实现对list迭代器的整型加法，itr为迭代器，i为所加的整数*/
list<int>::iterator pluss(list<int>::iterator itr,int i);

/*计算出迭代器find_相对于begin的距离，范围是begin到end，并且把所找到的迭代器赋给res*/
int dist(list<int>::iterator begin,list<int>::iterator end,list<int>::iterator find_,list<int>::iterator &res);

/*convert是把string转换到list<int>容器内的转换函数*/
void convert(string &str,list<int> &i_list);

void free_tree(void);

/*前序l_front,中序l_mid*/
static list<int> l_front;
static list<int> l_mid;

/*list_head用于记录所创建的tree
*index用于记录tree指针所存的位置
*/
static tree *list_head[100];
static int tree_index;

int main()
{
string front;
string mid;

tree_index=0;

cout<<"请输入树的前序遍历序列（空格隔开）："<<endl;
getline(cin,front);

cout<<"请输入树的中序遍历序列（空格隔开）："<<endl;
getline(cin,mid);

convert(front,l_front);
convert(mid,l_mid);

/*这里不考虑.end()因为后面迭代的时候分段，list段内是没有.end()的，而，rebuild_tree是需要递归的函数，这样是为了保持一致性*/
root=rebuild_tree(l_front.begin(),--l_front.end(),l_mid.begin(),--l_mid.end());

cout<<"Show Tree"<<endl;
show_tree(root);
cout<<endl;
free_tree();
}

tree *rebuild_tree(list<int>::iterator f_begin,list<int>::iterator f_end,list<int>::iterator m_begin,list<int>::iterator m_end)
{
list<int>::iterator tmp,res;
list<int>::iterator tmp1,tmp2,tmp3;
int dis;
tree *root=(tree*)malloc(sizeof(tree));

list_head[tree_index]=root;
tree_index++;

dis=dist(m_begin,m_end,f_begin,res);
root->m_nValue=*f_begin;

cout<<"dis:"<<dis<<endl;

/*如果list内的数据已经被加入二叉树节点，那么把该list的节点赋值为-1，便于后面判断边界*/
*f_begin=-1;

/*---------------------如果有左子树，往左遍历-----------------------------*/
tmp=res;
/*---------------------如果dis为0，则说明没左子树-------------------------------*/
if(tmp==l_mid.begin()||dis==0)
{
root->l_tree=NULL;
}
else if(*(--tmp)==-1)
{
root->l_tree=NULL;
}
else
{
tmp1=pluss(f_begin,1);
tmp2=pluss(f_begin,dis);
tmp3=pluss(m_begin,dis-1);

root->l_tree=rebuild_tree(tmp1,tmp2,m_begin,tmp3);
}
/*-----------------------如果有右子树，往右遍历---------------------------*/

tmp=res;
/*如果搜索所得的结果为该中序遍历list段尾部，那么他的右子树为NULL*/
if(tmp==m_end)
{
root->r_tree=NULL;
}
else{
tmp++;
if(*tmp==-1|| tmp==l_mid.end())
{
root->r_tree=NULL;
}
else
{
tmp1=pluss(f_begin,dis+1);
tmp2=pluss(res,1);

root->r_tree=rebuild_tree(tmp1,f_end,tmp2,m_end);
}
}
/*------------------------------------------------------------------*/
cout<<"add node:"<<root->m_nValue<<endl;
return root;
}

list<int>::iterator pluss(list<int>::iterator itr,int i)
{
for(;i>0;i--)
{
itr++;
}
return itr;
}

int dist(list<int>::iterator begin,list<int>::iterator end,list<int>::iterator find_,list<int>::iterator &res)
{
res=find_;
int i=0;
end++;
do
{
if(*begin==*res)
{
res=begin;
return i;
}
i++;
begin++;
}while(begin!=end);

if(res!=l_mid.end())
*res=-1;

return -1;
}

void show_tree(tree *root)
{
cout<<root->m_nValue<<",";
if(root->l_tree)
{
show_tree(root->l_tree);
}
if(root->r_tree)
{
show_tree(root->r_tree);
}
}

void convert(string &str,list<int> &i_list)
{
int i;

stringstream strOutput(str);
for(;strOutput>>i;)
{
i_list.push_back(i);
}

}

void free_tree(void)
{
for(;tree_index>=0;tree_index--)
free(list_head[tree_index]);
}