剑指Offer_面试题06_重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{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.首先取先序序列首元素，先序序列首元素必为当前树的根结点元素；

2.根据根结点元素，将中序序列分割为两个区域，左边为左子树中序序列，右边为右子树中序序列；

3.根据各个子树中序序列的长度，可以截取出各个子树的先序序列（因为长度一致且每个子树的先序序列是在一起的长度为中序序列长度）；

4.递归，如果序列长度为0则返回NULL。

根据这一思想，敲了一上午的代码，基本解决。有两个版本的函数，参数不同，分别对应剑指Offer原书和牛客网OJ版本。

#include <stdio.h>
#include <vector>
#include <iostream>
using namespace std;
/**
* Definition for binary tree
**/
struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

//剑指offer原书版，根据先序遍历序列、中序遍历序列重建二叉树
TreeNode* ConstructByPreIn(int *preOrder, int *inOrder, int length)
{
	if (preOrder == NULL || inOrder == NULL || length <= 0) return NULL;
	//新建结点,当前先序序列第一个元素为根结点
	int root_val = preOrder[0];	
	TreeNode *root = new TreeNode(root_val);
	//初始化左右子树参数
	int leftLength = 0;
	int rightLength = 0;
	//在中序序列中找到根节点的位置（必存在）
	for (int i = 0; i < length; i++)
	{
		if (inOrder[i] == root_val)
		{
			leftLength = i;
			rightLength = length - i - 1;
			break;
		}
	}
	//中序序列中，根节点左边的为左子树，右边的为右子树
	int *leftPre = preOrder + 1;
	int *leftIn = inOrder;
	int *rightPre = preOrder + leftLength + 1;
	int *rightIn = inOrder + leftLength + 1;
	//递归构建左右子树
	root->left = ConstructByPreIn(leftPre, leftIn, leftLength);
	root->right = ConstructByPreIn(rightPre, rightIn, rightLength);
	return root;

}

//牛客网版本，根据先序中序序列重建二叉树
TreeNode* reConstructBinaryTree(vector<int> preOrder, vector<int> inOrder) {
	if (preOrder.empty() || inOrder.empty()) return NULL;
	//新建结点,当前先序序列第一个元素为根结点
	int root_val = preOrder[0];
	TreeNode *root = new TreeNode(root_val);
	//初始化左右子树参数
	int leftLength = 0;
	int rightLength = 0;
	//在中序序列中找到根节点的位置（必存在）
	for (int i = 0; i < inOrder.size(); i++)
	{
		if (inOrder[i] == root_val)
		{
			leftLength = i;
			rightLength = inOrder.size() - i - 1;
			break;
		}
	}
	//中序序列中，根节点左边的为左子树，右边的为右子树
	vector<int> leftPre (preOrder.begin() + 1, preOrder.begin() + 1 + leftLength);
	vector<int> leftIn (inOrder.begin(), inOrder.begin() + leftLength);
	vector<int> rightPre (preOrder.begin() + leftLength + 1, preOrder.begin() + leftLength + 1 + rightLength);
	vector<int> rightIn (inOrder.begin() + leftLength + 1, inOrder.begin() + leftLength + 1 + rightLength);
	//递归构建左右子树
	root->left = reConstructBinaryTree(leftPre, leftIn);
	root->right = reConstructBinaryTree(rightPre, rightIn);
	return root;
}

//先序遍历
void PreOrder(TreeNode *root)
{
	if (root == NULL)
		return;
	std::cout << root->val << ' ';
	PreOrder(root->left);
	PreOrder(root->right);
}

//中序遍历
void InOrder(TreeNode *root)
{
	if (root == NULL)
		return;
	InOrder(root->left);
	std::cout << root->val << " ";
	InOrder(root->right);
}

//后序遍历
void PostOrder(TreeNode *root)
{
	if (root == NULL) return;
	PostOrder(root->left);
	PostOrder(root->right);
	std::cout << root->val << ' ';
}

int main()
{
	//原书版本函数测试
	int preOrder[] = { 1,2,4,7,3,5,6,8 };
	int inOrder[] = { 4,7,2,1,5,3,8,6 };
	TreeNode *tree = ConstructByPreIn(preOrder, inOrder, 8);
	PreOrder(tree);    //先序输出
	std::cout << std::endl;
	InOrder(tree);     //中序输出
	std::cout << std::endl;

	//牛客网版本函数测试
	vector<int> pre = { 1,2,4,7,3,5,6,8 };
	vector<int> in = { 4,7,2,1,5,3,8,6 };
	TreeNode *tree2 = reConstructBinaryTree(pre, in);
	PreOrder(tree2);    //先序输出
	std::cout << std::endl;
	InOrder(tree2);     //中序输出
	std::cout << std::endl;

	system("pause");
	return 0;
}

牛客网OJ通过测试，1ms。本地测试结果：

顺便实现一下二叉树层序遍历，层序遍历需要借助队列实现，这里采用两种方法1.STL的deque，2.数组模拟队列，代码如下：

#include <deque>
using namespace std;
//层序遍历
void LevelOrder(TreeNode *root)
{
	if (root == NULL) return;
	deque<TreeNode *> NodeDeque;
	NodeDeque.push_front(root);
	while (!NodeDeque.empty())
	{
		//输出队首结点元素值
		TreeNode *node = NodeDeque.front();
		cout << node->val << " ";
		if (node->left != NULL)
			NodeDeque.push_back(node->left);
		if (node->right != NULL)
			NodeDeque.push_back(node->right);
		//出队
		NodeDeque.pop_front();
	}
}

//层序遍历数组模拟队列
void LevelOrder2(TreeNode *root)
{
	if (root == NULL) return;
	//模拟队列
	TreeNode* nodeDeque[1024];
	int front = -1;    //队头指针初始化-1；
	int rear = 0;      //队尾初始化0，判空为front == rear
	nodeDeque[rear] = root;    //根节点入队
	while (front != rear)
	{
		++front;    //队头出队
		TreeNode *node = nodeDeque[front];    //取队头元素
		cout << node->val << ' ';
		if (node->left != NULL)
		{
			//左孩子不为空，左孩子入队
			nodeDeque[++rear] = node->left;
		}
		if (node->right != NULL)
		{
			//右孩子不为空，有孩子入队
			nodeDeque[++rear] = node->right;
		}
	}
}