2017年天梯赛全国总决赛题集 L3-1 二叉搜索树的结构 (30 分)(二叉搜索树，字符串)

描述：

二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。（摘自百度百科）

给定一系列互不相等的整数，将它们顺次插入一棵初始为空的二叉搜索树，然后对结果树的结构进行描述。你需要能判断给定的描述是否正确。例如将{ 2 4 1 3 0 }插入后，得到一棵二叉搜索树，则陈述句如“2是树的根”、“1和4是兄弟结点”、“3和0在同一层上”（指自顶向下的深度相同）、“2是4的双亲结点”、“3是4的左孩子”都是正确的；而“4是2的左孩子”、“1和3是兄弟结点”都是不正确的。

输入格式：

输入在第一行给出一个正整数N（≤100），随后一行给出N个互不相同的整数，数字间以空格分隔，要求将之顺次插入一棵初始为空的二叉搜索树。之后给出一个正整数M（≤100），随后M行，每行给出一句待判断的陈述句。陈述句有以下6种：

• A is the root，即"A是树的根"；
• A and B are siblings，即"A和B是兄弟结点"；
• A is the parent of B，即"A是B的双亲结点"；
• A is the left child of B，即"A是B的左孩子"；
• A is the right child of B，即"A是B的右孩子"；
• A and B are on the same level，即"A和B在同一层上"。

题目保证所有给定的整数都在整型范围内。

输出格式：

对每句陈述，如果正确则输出Yes，否则输出No，每句占一行。

输入样例：

5
2 4 1 3 0
8
2 is the root
1 and 4 are siblings
3 and 0 are on the same level
2 is the parent of 4
3 is the left child of 4
1 is the right child of 2
4 and 0 are on the same level
100 is the right child of 3

输出样例：

Yes
Yes
Yes
Yes
Yes
No
No
No

题意：

给定n个互不相等的整数，请你按照输入顺序建立一颗二叉搜索树，随后m条语句，判断给定的一个或两个点值是否符合描述，即判断是否为根，是否为左右儿子，父节点，兄弟节点等，如果是则输出Yes，不是则输出No

思路：

既然又是树的题目，首先就考虑选用怎样的数据结构去存下这棵树

先看能不能用类似完全二叉树的方式存下这棵树，即用数组去存。给定的节点数为n，n最大为100，最坏情况下形成的搜索树为一颗每个节点仅有右儿子的树，此时需要的存储空间为4*2^100 / 1024 / 1024 = 2^82M远大于给定的64M = 2^6  

所以开一个巨大的数组去存下每一个节点的值这样的方法是不可行的

我们再看到给定的整数都是互不相等的，那么我们用a[index] = value的形式不可行，我们把index和value交换一下，我们以a[value] = index的形式不就可以了吗

也就是说给定每一个节点的值，我们通过数组的转换都能够得到他本该在以a[index] = value 的下标是什么，这样也比第一种方法少了一个搜索的过程

还有一点就是，题目只是说节点的值为整数，但并没有说是正整数，所以这里不能用普通的数组去存，这里我用的是unordered_map去存，就是无顺序的哈希表

那得到每个值对应的下标有什么用呢？其实如果得到了每个节点的下标，那么判断这些语句，就会十分得方便，就不需要每次都遍历这棵树

0.判断根节点，只需要判断对应的下标是不是1(下标从1开始储存)

1.判断兄弟节点，只需要判断对应的父节点是否相同，即二者的下标同除以2，判断相等即可

2.判断双亲节点，只需要判断儿子节点的下标除以二是否等于另一个节点的下标即可(注意不能反过来判断，是不是自己的儿子，因为有左右儿子之分，如果非要这样的话，就需要判断两次，是左或是右儿子)

3.判断左儿子，左儿子下标 = 父节点下标 * 2

4.判断右儿子，右儿子下标 = 父节点下标 * 2 + 1

5.判断是否处于同一层，这里可以用下标去判断，就是比较麻烦，观察同一层下标的范围，第一层 1，第二层 2 3，第三层 4 5 6 7，第四层 8 9 10 11 12 13 14 15，会发现，如果是同一层的下标，都会在2^n~2^n - 1之间，这样判断就需要遍历一遍了，所以这里我另外定义了一个deep数组去直接对值和深度进行映射，直接在O(1)内完成比较，同样这里也是用的unordered_map去定义的deep，deep和indexs这两个哈希表在插入的时候就可以完成赋值，插入的时候根据二叉树的性质，左小右大

再说如何判断给定的语句：这里具有可以用string 自带的find函数，一些特别的语句可以直接判断首尾字符，就不用搜索一遍了。随后再用sscanf(这个函数与scanf的最大区别就是，scanf是从控制台读取输入，而sscanf是从字符串中读取输入，其实就是在scanf的参数前面再加上要从哪读取，后面两个参数的用法和scanf完全相同，可以理解为，scanf默认从控制台读入)

还有比较坑的地方就是，题目让我们判断时给定的数可以是不存在的，也就是不在树里，这里需要特判一下，其实就直接判断对应的下标是否为零即可，因为哈希表int默认为零，而下标是从1开始的

代码： 

//L3-1 二叉搜索树的结构 (30 分)
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<unordered_map>
using namespace std;
const int N = 110;

int l[N] , r[N] , v[N] , idx;
int n , m , num , root , a , b;
unordered_map<int , int> deep , indexs;

//二叉搜索树插入模板，l，r存左右儿子的下标(按顺序存放，通过下标映射)，v表示值
void insert(int &u , int num , int deepth , int id)
{
	if(!u)
	{
		u = ++idx;
		v[u] = num;
		deep[num] = deepth;
		indexs[num] = id;
	}
	else if(v[u] > num)
		insert(l[u] , num , deepth + 1 , 2 * id);
	else
		insert(r[u] , num , deepth + 1 , 2 * id + 1);
}

void judge(int x , int y)        //封装判断函数，在判断值相等的同时，判断两个节点是否在树中
{
	cout<<(x == y && x && y ? "Yes" : "No")<<endl; 
} 

int main()
{
	cin>>n;
	for(int i = 0 ; i < n ; i++)
	{
		cin>>num;
		insert(root , num , 0 , 1);
	}
	
	cin>>m;
	getchar();                              //吸收换行符
	while(m--)
	{
		string str;
		getline(cin , str);
		
		if(str.back() == 't')				//判断根节点 
		{
			sscanf(str.c_str() , "%d is the root" , &a);
			judge(indexs[a] , 1);
		}
		else if(str.back() == 's')			//判断兄弟节点 
		{
			sscanf(str.c_str() , "%d and %d are siblings" , &a , &b);
			judge(indexs[a] / 2 , indexs[b] / 2);
		}
		else if(str.back() == 'l')			//判断层数 
		{
			sscanf(str.c_str() , "%d and %d are on the same level" , &a , &b);
			judge(deep[a] , deep[b]);
		}
		else if(str.find("parent") != -1)	//判断父节点 
		{
			sscanf(str.c_str() , "%d is the parent of %d" , &a , &b);
			judge(indexs[a] , indexs[b] / 2);
		}
		else if(str.find("left") != -1)		//判断左儿子 
		{
			sscanf(str.c_str() , "%d is the left child of %d" , &a , &b);
			judge(indexs[a], indexs[b] * 2);
		}
		else								//判断右儿子 
		{
			sscanf(str.c_str() , "%d is the right child of %d" , &a , &b);
			judge(indexs[a] , indexs[b] * 2 + 1);
		}
	}
	return 0;
}