九度OJ_1385：重建二叉树

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



输入：
输入可能包含多个测试样例，对于每个测试案例，

输入的第一行为一个整数n(1<=n<=1000)：代表二叉树的节点个数。

输入的第二行包括n个整数(其中每个元素a的范围为(1<=a<=1000))：代表二叉树的前序遍历序列。

输入的第三行包括n个整数(其中每个元素a的范围为(1<=a<=1000))：代表二叉树的中序遍历序列。

输出：
对应每个测试案例，输出一行：

如果题目中所给的前序和中序遍历序列能构成一棵二叉树，则输出n个整数，代表二叉树的后序遍历序列，每个元素后面都有空格。

如果题目中所给的前序和中序遍历序列不能构成一棵二叉树，则输出”No

#include
#define MAX 1001

// 构建二叉树的结点
typedef struct Node
{
int data;            // 数据域
Node * lChild;       // 左子树
Node * rChild;       // 右子树
}BinaryTreeNode;
BinaryTreeNode biTreeNode[MAX];

bool canRebuildBinaryTree; // 判断能否重构二叉树
int preOrder[MAX];      // 二叉树的前序遍历序列
int inOrder[MAX];       // 二叉树的中序遍历序列

/**
* 初始化二叉树中的每个结点，将每个结点都看成是只有一个根结点而左右子树都为NULL的二叉树
* @param int n  二叉树的结点数
* @return void
*/
void initBinaryTree(int n)
{
int i;
canRebuildBinaryTree = true;
for(i = 0;i < n;i++)
{
biTreeNode[i].data = preOrder[i];  // 将前序遍历序列中的元素依次赋值给二叉树中的结点
biTreeNode[i].lChild = NULL;
biTreeNode[i].rChild = NULL;
}
}

/**
* 重构二叉树
* @param int beginPreOrder  前序遍历序列的起点
* @param int endPreOrder  前序遍历序列的终点
* @param int beginInOrder  中序遍历序列的起点
* @param int endInOrder  中序遍历序列的终点
* @return void
*/
void reBuildBinaryTree(int beginPreOrder,int endPreOrder,int beginInOrder,int endInOrder)
{
int i;
int partion = -1;     // 前序遍历序列第一个结点在中序遍历序列中的相对位置
bool isBeginPreOrderinInOrder = false; // 判断前序遍历序列中的第一个结点是否在中序遍历序列中，以此来判断是否能构成二叉树
// 遍历二叉树的中序遍历序列，得到根结点在中序遍历序列中的位置
for(i = beginInOrder;i <= endInOrder;i++)
{
if(preOrder[beginPreOrder] == inOrder[i])
{
partion = i - beginInOrder;
isBeginPreOrderinInOrder = true;
break;
}
}
if(false == isBeginPreOrderinInOrder)
{
canRebuildBinaryTree = false;
return;
}
else
{
// 以partion为分隔标识
// 将前序遍历序列分为[beginPreOrder + 1,beginPreOrder + partion]
// 和[beginPreOrder + partion + 1,endPreOrder]两个子序列
// 将中序遍历序列分为[beginInOrder,beginInOrder + partion - 1]
// 和[beginInOrder + partion + 1,endInOrder]两个子序列

// 用前序遍历子序列[beginPreOrder + 1,beginPreOrder + partion]
// 和中序遍历子序列[beginInOrder,beginInOrder + partion - 1]重构左子树
if(beginPreOrder + 1 <= beginPreOrder + partion && beginInOrder <= beginInOrder + partion - 1)
{
biTreeNode[beginPreOrder].lChild = &biTreeNode[beginPreOrder + 1];
reBuildBinaryTree(beginPreOrder + 1,beginPreOrder + partion,beginInOrder,beginInOrder + partion - 1);
}
// 用前序遍历子序列[beginPreOrder + partion + 1,endPreOrder]
// 和中序遍历子序列[beginInOrder + partion + 1,endInOrder]重构右子树
if(beginPreOrder + partion + 1 <= endPreOrder && beginInOrder + partion + 1 <= endInOrder)
{
biTreeNode[beginPreOrder].rChild = &biTreeNode[beginPreOrder + partion + 1];
reBuildBinaryTree(beginPreOrder + partion + 1,endPreOrder,beginInOrder + partion + 1,endInOrder);
}
}
}

/**
* 后序遍历二叉树
* @param BinaryTreeNode * root  后序遍历的根结点
* @return void
*/
void postOrder(BinaryTreeNode * root)
{
if(NULL == root)
return;
else
{
postOrder(root -> lChild);
postOrder(root -> rChild);
printf("%d ",root -> data);
}
}

int main()
{
int n;
int i;
while(EOF != scanf("%d",&n))
{
for(i = 0;i < n;i++)
{
scanf("%d",&preOrder[i]);
}
for(i = 0;i < n;i++)
{
scanf("%d",&inOrder[i]);
}
initBinaryTree(n);
reBuildBinaryTree(0,n - 1,0,n - 1);
if(false == canRebuildBinaryTree)
printf("No\n");
else
{
postOrder(&biTreeNode[0]); //因为 biTreeNode[0].data == preOrder[0]，所以biTreeNode[0]是重构二叉树的根结点
printf("\n");
}
}
return 0;
}