面试题6： 二叉树的重建

1. 题目：给定一棵二叉树的前序遍历序列和中序遍历序列，重建该二叉树。

分析：

在二叉树的前序遍历序列中，第一个数字总是该二叉树的根节点的值，但在中序遍历中，根节点在中间的位置，而此时可以根据根节点在中序遍历序列中的位置，找到该二叉树的左子树部分和右子树部分，对应于前序遍历的序列，也可以划分成三个部分，根节点，左子树部分和右子树部分。在用同样的方法在左右子树部分序列中构建二叉树，可以使用递归的方法来构建，最后按照前序遍历的方法打印出这棵二叉树。

源码：

#include<iostream>
using namespace std;
//the stucture of the binarytree
struct BinaryTreeNode
{
	int m_nValue;
	BinaryTreeNode* m_pLeft;
	BinaryTreeNode* m_pRight;
};
//the process to construct
BinaryTreeNode* ConstructCore(int* startPreorder, int* endPreorder, int* startInorder, int* endInorder);

BinaryTreeNode* Construct(int* preorder, int* inorder, int length)
{
	if (preorder == NULL || inorder == NULL || length <= 0)
		return NULL;

	return ConstructCore(preorder, preorder + length - 1,
		inorder, inorder + length - 1);
}

BinaryTreeNode* ConstructCore(int* startPreorder, int* endPreorder, int* startInorder, int* endInorder)
{
	// the first number of the preorder is the root 
	int rootValue = startPreorder[0];
	BinaryTreeNode* root = new BinaryTreeNode();
	root->m_nValue = rootValue;
	root->m_pLeft = NULL;
	root->m_pRight = NULL;
	if (startPreorder == endPreorder)//if only root node exits
	{
		if (startInorder == endInorder && *startPreorder == *startInorder)
			return root;
		else
			throw std::exception("Invalid input.");
	}

	// 在中序遍历中找到根结点的值
	int* rootInorder = startInorder;
	while (rootInorder <= endInorder && *rootInorder != rootValue)
		++rootInorder;

	if (rootInorder == endInorder && *rootInorder != rootValue)//can't find the root in the inorder
		throw std::exception("Invalid input.");

	int leftLength = rootInorder - startInorder;//caculate the length of the left child tree
	int* leftPreorderEnd = startPreorder + leftLength;//the Boundary of the left child tree
	if (leftLength > 0)
	{
		// construct the left child tree
		root->m_pLeft = ConstructCore(startPreorder + 1, leftPreorderEnd,
			startInorder, rootInorder - 1);
	}
	if (leftLength < endPreorder - startPreorder)
	{
		// construct the right child tree
		root->m_pRight = ConstructCore(leftPreorderEnd + 1, endPreorder,
			rootInorder + 1, endInorder);
	}

	return root;
}

void PrintTreeNode(BinaryTreeNode* pNode)
{
	if (pNode != NULL)
	{
		printf("value of this node is: %d\n", pNode->m_nValue);

		if (pNode->m_pLeft != NULL)
			printf("value of its left child is: %d.\n", pNode->m_pLeft->m_nValue);
		else
			printf("left child is null.\n");

		if (pNode->m_pRight != NULL)
			printf("value of its right child is: %d.\n", pNode->m_pRight->m_nValue);
		else
			printf("right child is null.\n");
	}
	else
	{
		printf("this node is null.\n");
	}

	printf("\n");
}

//Preorder traversal the tree
void PrintTree(BinaryTreeNode* pRoot)
{
	PrintTreeNode(pRoot);

	if (pRoot != NULL)
	{
		if (pRoot->m_pLeft != NULL)
			PrintTree(pRoot->m_pLeft);

		if (pRoot->m_pRight != NULL)
			PrintTree(pRoot->m_pRight);
	}
}

void DestroyTree(BinaryTreeNode* pRoot)
{
	if (pRoot != NULL)
	{
		BinaryTreeNode* pLeft = pRoot->m_pLeft;
		BinaryTreeNode* pRight = pRoot->m_pRight;

		delete pRoot;
		pRoot = NULL;

		DestroyTree(pLeft);
		DestroyTree(pRight);
	}
}

int main()
{
	const int length = 8;
	int preorder[length] = { 1, 2, 4, 7, 3, 5, 6, 8 };//preorder sequence
	int inorder[length] = { 4, 7, 2, 1, 5, 3, 8, 6 };//inorder sequence
	BinaryTreeNode* root = Construct(preorder, inorder, length);
	PrintTree(root);

	DestroyTree(root);

	system("PAUSE");
	return 0;
}