爱之树（二叉树建树+搜索）

题目链接：题目详情 - 7-15 Tree of Love (pintia.cn)

 样例1输入：

27
5 4 6 22 3 23 7 20 2 21 8 18 9 1 10 19 11 24 17 25 12 26 16 27 13 15 14
5 6 22 4 7 23 20 3 8 21 9 18 2 10 11 24 19 12 26 25 13 27 14 15 16 17 1

样例1输出：

Yes
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

样例2输入：

11
4 8 10 2 5 1 6 3 9 11 7
10 8 4 5 2 6 11 9 7 3 1

样例2输出：

No
1 2 4 10 5 6 11 7 3

分析：首先题目中说的无序遍历其实就是中序遍历，我们首先要做的就是根据树的中序遍历和后序遍历来确定出这棵二叉树，然后我们就可以判断这棵树是否对称，这个也很好判断，我们用两个队列，一开始里面只有根节点，然后一个队列访问左子树，另一个队列访问右子树，我们对应地取出两个队列的队首元素，如果一个队列的首部元素有左子树，那么另一个队列的首部元素就要有右子树，同理，如果一个队列的首部元素有右子树，那么另一个队列的首部元素就要有左子树。如果一直都满足这样的条件，那么这棵树就是对称的，否则就不是对称的。我们在建树过程中顺便存储一下树的叶子节点并记录其深度，然后对叶子节点按照顺序进行判断其深度是否呈现题目中所给的规律就行，因为是对称的，所以只要一半满足规律即可。最后就是一个外部轮廓问题，这个外部轮廓有点歧义，比如示例二中的树如下图：

 他的轮廓是1 2 4 10 5 6 11 7 3 1，我一开始以为他的轮廓是1 2 4 8 10 5 6 11 9 7 3

后来发现他的轮廓就是从根节点开始一直往左孩子方向搜索，直到某个节点没有左孩子为止，右边轮廓就是一直往右孩子方向搜索，直到某个节点没有右孩子为止，这个地方需要大家注意一下，其他没什么了，细节见代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
#include<queue>
#include<vector>
#include<cmath>
using namespace std;
const int N=1e3+10;
int l[N],r[N];
int a[N],b[N],c[N],mp[N];
int d[N];//记录节点深度 
vector<int> p;//统计叶子节点 
int build_23(int l1,int r1,int l2,int r2,int h)
{
	if(l1>r1) return 0;
//	printf("%d ",c[r2]);
	l[c[r2]]=build_23(l1,mp[c[r2]]-1,l2,l2+(mp[c[r2]]-1-l1),h+1);
	r[c[r2]]=build_23(mp[c[r2]]+1,r1,l2+(mp[c[r2]]-1-l1)+1,r2-1,h+1);
	d[c[r2]]=h;
	if(!l[c[r2]]&&!r[c[r2]]) p.push_back(c[r2]);
	return c[r2];
}
int main()
{
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)
		cin>>b[i],mp[b[i]]=i;
	for(int i=1;i<=n;i++)
		cin>>c[i];
	int root=build_23(1,n,1,n,1);
	bool flag=true;//判断该树是否对称 
	queue<int>q1,q2;
	q1.push(root);
	q2.push(root);
	while(!q1.empty())
	{
		int t1=q1.front(),t2=q2.front();
		q1.pop();q2.pop();
		if(l[t1]&&r[t2])//左边有左子树并且右边有右子树 
		{
			q1.push(l[t1]);
			q2.push(r[t2]);
		}
		else if(l[t1]||r[t2])//左边有左子树和右边有右子树有且只有一个成立 
		{
			flag=false;
			break;
		}
		if(r[t1]&&l[t2])//左边有右子树并且右边也有左子树 
		{
			q1.push(r[t1]);
			q2.push(l[t2]);
		}
		else if(r[t1]||l[t2])//左边有右子树和右边有左子树有且只有一个成立 
		{
			flag=false;
			break;
		}
	}
	if(!q2.empty()) flag=false;//这个时候也是不对称的 
	int i=1;
	while(i<p.size()/2&&d[p[i]]>=d[p[i-1]]) i++;
	while(i<p.size()/2&&d[p[i]]<=d[p[i-1]]) i++;
	if(i<p.size()/2) flag=false;
	if(flag) puts("Yes");
	else puts("No");
	int a[N],b[N],len1=0,len2=0; 
	queue<int> q;
	q.push(root);
	while(!q.empty())
	{
		int t=q.front();
		q.pop();
		a[++len1]=t;
		if(l[t])
			q.push(l[t]);
		else break;
	}
	q.push(root);
	while(!q.empty())
	{
		int t=q.front();
		q.pop();
		b[++len2]=t;
		if(r[t])
			q.push(r[t]);
		else break;
	}
	if(a[len1]==p[0]) len1--;
	if(b[len2]==p[p.size()-1]) len2--;
	for(int i=1;i<=len1;i++)
		printf("%d ",a[i]);
	for(int i=len2;i>1;i--)
		p.push_back(b[i]);
	for(int i=0;i<p.size();i++)
	{
		printf("%d",p[i]);
		if(i!=p.size()-1) printf(" ");
	}
	return 0;
}