二叉树经典问题-根据层序与中序重建二叉树+前序后序无法确定二叉树的原因（另附前序，后序）

敲层序与中序花了好一会儿功夫
总体思路：
前后层序均是为二叉树提供根节点；中序是依据所提供的根节点来划分左右子树；然后递归，在左右子树中继续寻找根节点划分左右子树，直到遍历完所有子树。

层序与中序

给出层序中序重建二叉树方法与给出前后序的思路略有不同
层序遍历的特点是所有的根节点均依次在序列的前面，并且序列中左右子树混乱排列，并不集中。
因此层序的难点在于

• 找出根节点（因为所有根节点均排列在序列最前面）
• 划分左右子树（层序中左右子树划分不明确）

解决方法：

• 关于根节点：顺序遍历层序列，将每一个节点当做根节点，并在中序中找出相应根节点，记录下标
• 关于左右子树：借助中序划分左右子树，将左子树挂在根节点的lchild，右子树挂在根节点的rchild并进行递归
• hashtable[]：标记lay[]元素是否被访问，防止左子树递归访问后右子树重复访问

递归参数：层序中序的左右下标
递归体：

• 依次遍历层序中的根节点，并在中序中找到根节点所在下标
• 根据中序得到的下标划分左右子树
• 对左右子树做递归操作，并将左右子树分别挂在根节点的左右子节点上

递归边界：子树为空时return NULL，即序列左侧下标超过了右侧下标

#include <bits/stdc++.h>
using namespace std;
int lay[10] = {1, 2, 3, 4, 5, 6, 7};
int in[10] = {4, 2, 5, 1, 6, 3, 7};
bool hashtable[10];//标记lay[]元素是否被访问（是否在树的集合内）
struct Node{
	int data;
	int layer = 0;
	Node* lchild;
	Node* rchild;
};
Node* newNode(int v)
{
	Node* node = new Node;
	node->data = v;
	node->lchild = node->rchild = NULL;
	return node;
}
Node* recreate(int layL, int layR, int inL, int inR)
{
	//边界 
	if(inL > inR)
	{
		return NULL;
	}
	int x, y;
	Node* root = NULL;
	//在中序序列里找到层序的一个根节点，跳出循环进入递归 
	for(x = layL; x <= layR; ++x)//层序的特点，根节点排在前面 （外循环含义：把每一个节点都当做根节点） 
	{
		if(hashtable[x])//该节点已访问 
			continue;
		bool flag = false;//标记是否在中序序列里找到根节点，若找到跳出所有 
		for(y = inL; y <= inR; ++y)
		{
			if(lay[x] == in[y])//在中序序列里 找到层序遍历到的根节点lay[x] 
			{
				flag = true; 
				break;
			}
		}
		if(flag)
		{
			hashtable[x] = true;
			root = newNode(lay[x]);
			root->lchild = recreate(x + 1, layR, inL, y - 1);//中序划分的左子树
			root->rchild = recreate(x + 1, layR, y + 1, inR);//中序划分的右子树 
			//由于层序是顺序遍历并做访问标记，直接从x+1即可 
		}
	}
	return root;
}
void layerOrder(Node* root)
{
	queue<Node*> q;
	root->layer = 1;
	q.push(root);
	while(!q.empty())
	{
		Node* now = q.front();
		q.pop();
		printf("(%d,%d)\n", now->data, now->layer);
		if(now->lchild != NULL)
		{
			now->lchild->layer = now->layer + 1;
			q.push(now->lchild);
		}
		if(now->rchild != NULL)
		{
			now->rchild->layer = now->layer + 1;
			q.push(now->rchild);
		}
	}
}
int main(int argc, char *argv[]) {
	Node* root = recreate(0, 6, 0, 6);
	layerOrder(root);
	return 0;
}

前序与后序（可能重构的树不唯一，存在唯一的情况）

思路解析：PAT甲组1119 Pre- and Post-order Traversals

前序与中序

递归参数：前序中序的左右下标
递归体：

• 在前序中找到根节点，并在中序中找到根节点所在下标
• 根据中序得到的下标划分左右子树，同时在前序中同样划分左右子树
• 对左右子树做递归操作，并将左右子树分别挂在根节点的左右子节点上

递归边界：子树为空时return NULL，即序列左侧下标超过了右侧下标

#include <bits/stdc++.h>
using namespace std;
int pre[10] = {1, 2, 4, 5, 3, 6, 7};
int in[10] = {4, 2, 5, 1, 6, 3, 7};
struct Node{
	int data;
	int layer = 0;
	Node* lchild;
	Node* rchild;
};
Node* newNode(int v)
{
	Node* node = new Node;
	node->data = v;
	node->lchild = node->rchild = NULL;
	return node;
}
Node* recreate(int preL, int preR, int inL, int inR)
{
	if(preL > preR)//边界 
		return NULL;
	Node* root = newNode(pre[preL]);//先序的根节点 
	int k;//记录中序根节点的下标 
	for(k = inL; k <= inR; k++)//在中序中找到根节点 
	{
		if(in[k] == pre[preL])
			break;
	}
	int numLeft = k - inL;//中序左子树的节点数 
	root->lchild = recreate(preL + 1, preL + numLeft, inL, k - 1);
	root->rchild = recreate(preL + numLeft + 1, preR, k + 1, inR);
	return root;
}
void layerOrder(Node* root)
{
	queue<Node*> q;
	root->layer = 1;
	q.push(root);
	while(!q.empty())
	{
		Node* now = q.front();
		q.pop();
		printf("(%d,%d)\n", now->data, now->layer);
		if(now->lchild != NULL)
		{
			now->lchild->layer = now->layer + 1;
			q.push(now->lchild);
		}
		if(now->rchild != NULL)
		{
			now->rchild->layer = now->layer + 1;
			q.push(now->rchild);
		}
	}
}
int main(int argc, char *argv[]) {
	Node* root = recreate(0, 6, 0, 6);
	layerOrder(root);
	return 0;
}

后序与中序

PAT A组1020

题目链接
与前序中序的思想一致
递归参数：后序中序的左右下标
递归体：

• 在后序中找到根节点，并在中序中找到根节点所在下标
• 根据中序得到的下标划分左右子树，同时在后序中同样划分左右子树
• 对左右子树做递归操作，并将左右子树分别挂在根节点的左右子节点上

递归边界：子树为空时return NULL，即序列左侧下标超过了右侧下标

#include <bits/stdc++.h>
using namespace std;
int N, post[35], in[35], cnt = 0;
struct Node{
	int data;
	Node* lchild;
	Node* rchild;
};
Node* newNode(int v)
{
	Node* node = new Node;
	node->data = v;
	node->lchild = node->rchild = NULL;
	return node;
}
Node* recreate(int postL, int postR, int inL, int inR)
{
	if(postL > postR)
		return NULL;
	Node* root = newNode(post[postR]);//后序根节点
	int k;
	for(k = inL; k <= inR; ++k)
	{
		if(in[k] == post[postR])
			break;
	} 
	int numLeft = k - inL;
	root->lchild = recreate(postL, postL + numLeft - 1, inL, k - 1);
	root->rchild = recreate(postL + numLeft, postR - 1, k + 1, inR);
	return root;
	return root;
}
void levelOrder(Node* root)
{
	queue<Node*> q;
	q.push(root);
	while(!q.empty())
	{
		Node* now = q.front();
		q.pop();
		cnt++;
		if(cnt < N)
			printf("%d ", now->data);
		else
			printf("%d", now->data);
		if(now->lchild != NULL)
			q.push(now->lchild);
		if(now->rchild != NULL)
			q.push(now->rchild);
	}
}
int main(int argc, char *argv[]) {
	scanf("%d", &N);
	for(int i = 0; i < N; i++)
	{
		scanf("%d", &post[i]);
	}
	for(int i = 0; i < N; i++)
	{
		scanf("%d", &in[i]);
	}
	Node* root = recreate(0, N - 1, 0, N- 1);
	levelOrder(root);
	return 0;
}

静态树–void声明recreate

#include <bits/stdc++.h>
using namespace std;
const int maxn = 50010;
int N;
int pre[maxn], in[maxn];
struct Node{
	int data;
	int left, right;
	Node(){}
	Node(int d, int l, int r)
	{
		data = d;
		left = l;
		right = r;
	}
}nodes[maxn];
int pos;
int newNode(int x)
{
	nodes[pos] = Node(x, -1, -1);
	return pos++;
}
void recreate(int &root, int preL, int preR, int inL, int inR)
{
	if(preL > preR)
	{
		return;
	}
	root = newNode(pre[preL]);
	int k;
	for(k = inL; k < inR; ++k)
	{
		if(in[k] == pre[preL])
		{
			break;
		}
	}
	int numleft = k - inL;
	recreate(nodes[root].left, preL + 1, preL + numleft, inL, k - 1);
	recreate(nodes[root].right, preL + numleft + 1, preR, k + 1, inR);
	
}