剑指offer面试题7——重建二叉树

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

 

思路：

       二叉树的重建思路都是类似的，首先要知道两个序列，其中必定有一个是中序遍历序列，另一个可以是其他的序列。就这道题来说，我们可以通过先序序列知道二叉树的根节点为1，在中序序列里面1的左边是左子树的所有结点，1的右边是右子树的所有结点，这样就可以得到一棵树的结构。用递归的方法，求出左右子树的根节点，分别为根节点的左右孩子，递归下去就可以求得重建好的二叉树，并且将根节点的指针返回。

代码：

#include <iostream>


struct BinaryTreeNode {
	int   m_nValue;
	BinaryTreeNode*  m_pLeft;
	BinaryTreeNode*  m_pRight;
};

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)
{
	//前序遍历的第一个数字是根节点的值
	int rootValue = startPreorder[0];
	BinaryTreeNode* root = new BinaryTreeNode;
	root->m_nValue = rootValue;
	root->m_pLeft = root->m_pRight = NULL;
	if (startPreorder == endPreorder) {
		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)
		throw std::exception("Invalid input.");

	int leftLength = rootInorder - startInorder;
	int* leftPreorderEnd = startPreorder + leftLength;
	if (leftLength > 0)
	{
		//构件左子树，如果上面括号里取等于0，说明左子树不存在
		root->m_pLeft = ConstructCore(startPreorder + 1, leftPreorderEnd, startInorder, rootInorder - 1);
	}
	if (leftLength < endPreorder - startPreorder);
	{
		//构建右子树，如果上面括号里取等号，那么说明右子树不存在
		root->m_pRight = ConstructCore(leftPreorderEnd + 1, endPreorder, rootInorder + 1, endPreorder);
	}
	return root;

}

复习：这道题思路比较简单，主要是考虑代码的鲁棒性，以及递归函数的写法，需要多练习几次，掌握好递归的写法。

二刷代码：

struct BinaryTreeNode
{
	int                 m_nValue;
	BinaryTreeNode*     m_pLeft;
	BinaryTreeNode*     m_Right;
};

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

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

BinaryTreeNode* ConstructCore(int* startPreorder, int* endPreorder, int* startInorder, int* endInorder)
{
	int rootValue = startInorder[0];
	BinaryTreeNode* root = new BinaryTreeNode();
	root->m_nValue = rootValue;
	root->m_pLeft = root->m_Right = nullptr;

	if (startPreorder == endPreorder)
	{
		if (startInorder == startPreorder && *startInorder == *startPreorder)
			return root;
		else
			throw exception("Invalid input");
	}

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

	if (rootInorder == endInorder && *rootInorder != rootValue)
		throw exception("Invalid input");

	int leftLength = rootInorder - startInorder;
	int* leftPreorderEnd = startInorder + leftLength;
	if (leftLength > 0)
	{
		root->m_pLeft = ConstructCore(startPreorder + 1, leftPreorderEnd, startInorder, rootInorder - 1);
	}
	if (leftLength < endPreorder - startPreorder)
	{
		root->m_Right = ConstructCore(leftPreorderEnd + 1, endPreorder, rootInorder + 1, endInorder);
	}

	return root;

}