7-4 Structure of a Binary Tree (30分)

7-4 Structure of a Binary Tree (30分)

Suppose that all the keys in a binary tree are distinct positive integers. Given the postorder and inorder traversal sequences, a binary tree can be uniquely determined.

Now given a sequence of statements about the structure of the resulting tree, you are supposed to tell if they are correct or not. A statment is one of the following:

A is the root
A and B are siblings
A is the parent of B
A is the left child of B
A is the right child of B
A and B are on the same level
It is a full tree

Note:
Two nodes are on the same level, means that they have the same depth.
A full binary tree is a tree in which every node other than the leaves has two children.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤30), the total number of nodes in the binary tree. The second line gives the postorder sequence and the third line gives the inorder sequence. All the numbers in a line are no more than 10³ and are separated by a space.
Then another positive integer M (≤30) is given, followed by M lines of statements. It is guaranteed that both A and B in the statements are in the tree.

Output Specification:

For each statement, print in a line Yes if it is correct, or No if not.

Sample Input:

9
16 7 11 32 28 2 23 8 15
16 23 7 32 11 2 28 15 8
7
15 is the root
8 and 2 are siblings
32 is the parent of 11
23 is the left child of 16
28 is the right child of 2
7 and 11 are on the same level
It is a full tree

Sample Output:

Yes
No
Yes
No
Yes
Yes
Yes

注意点：
主要是sscanf的使用，不然字符串提取数字很麻烦。

#include<iostream>
#include<vector>
#include<unordered_map>
#include<string>
using namespace std;
vector<int> postorder, inorder;
unordered_map<int, int> inIndex;
bool isFull = true;
struct node {
	int val, depth;
	node *left, *right, *parent;
	node(int v) {
		val = v;
		left = NULL;
		right = NULL;
		parent = NULL;
	}
}*root = NULL;
unordered_map<int, node*> val2Node;
void build(node *&cur, int inLeft, int inRight, int postLeft, int postRight, int depth) {
	if (inLeft > inRight) {
		return;
	}
	int val = postorder[postRight], mid = inIndex[val], leftCount = mid - inLeft, rightCount = inRight - mid;
	cur = new node(val);
	val2Node[val] = cur;
	cur->depth = depth;
	build(cur->right, mid + 1, inRight, postRight - rightCount, postRight - 1, depth + 1);
	build(cur->left, inLeft, mid - 1, postLeft, postLeft + leftCount - 1, depth + 1);
	if (cur->left != NULL) {
		cur->left->parent = cur;
	}
	if (cur->right != NULL) {
		cur->right->parent = cur;
	}
	if (cur->left != NULL && cur->right == NULL || cur->left == NULL && cur->right != NULL) {
		isFull = false;
	}
}
node* getNode(int val) {
	return val2Node[val];
}
int main() {
	int n, m;
	cin >> n;
	postorder.resize(n);
	inorder.resize(n);
	for (int i = 0; i < n; i++) {
		cin >> postorder[i];
	}
	for (int i = 0; i < n; i++) {
		cin >> inorder[i];
		inIndex[inorder[i]] = i;
	}
	build(root, 0, n - 1, 0, n - 1, 1);
	cin >> m;
	cin.get();	//换行符
	for (int i = 0; i < m; i++) {
		string s;
		int a, b;
		bool correct = false;
		getline(cin, s);
		if (s.find("root") != string::npos) {
			sscanf(s.c_str(), "%d is the root", &a);
			if (root->val == a) {
				correct = true;
			}
		}
		else if (s.find("siblings") != string::npos) {
			sscanf(s.c_str(), "%d and %d are siblings", &a, &b);
			node *na = getNode(a), *nb = getNode(b);
			if (na->parent == nb->parent) {
				correct = true;
			}
		}
		else if (s.find("parent") != string::npos) {
			sscanf(s.c_str(), "%d is the parent of %d", &a, &b);
			node *na = getNode(a), *nb = getNode(b);
			if (nb->parent == na) {
				correct = true;
			}
		}
		else if (s.find("left child") != -1) {
			sscanf(s.c_str(), "%d is the left child of %d", &a, &b);
			node *na = getNode(a), *nb = getNode(b);
			if (nb->left == na) {
				correct = true;
			}
		}
		else if (s.find("right child") != -1) {
			sscanf(s.c_str(), "%d is the right child of %d", &a, &b);
			node *na = getNode(a), *nb = getNode(b);
			if (nb->right == na) {
				correct = true;
			}
		}
		else if (s.find("level") != -1) {
			sscanf(s.c_str(), "%d and %d are on the same level", &a, &b);
			node *na = getNode(a), *nb = getNode(b);
			if (na->depth == nb->depth) {
				correct = true;
			}
		}
		else {
			correct = isFull;
		}
		if (correct) {
			cout << "Yes" << endl;
		}
		else cout << "No" << endl;
	}
}