pat甲级1099 build a Binary Search Tree

1099 Build A Binary Search Tree (30 分)

A Binary Search Tree (BST) is recursively defined as a binary tree which has the following properties:

The left subtree of a node contains only nodes with keys less than the node's key.
The right subtree of a node contains only nodes with keys greater than or equal to the node's key.
Both the left and right subtrees must also be binary search trees.

Given the structure of a binary tree and a sequence of distinct integer keys, there is only one way to fill these keys into the tree so that the resulting tree satisfies the definition of a BST. You are supposed to output the level order traversal sequence of that tree. The sample is illustrated by Figure 1 and 2.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤100) which is the total number of nodes in the tree. The next N lines each contains the left and the right children of a node in the format left_index right_index, provided that the nodes are numbered from 0 to N−1, and 0 is always the root. If one child is missing, then −1 will represent the NULL child pointer. Finally N distinct integer keys are given in the last line.

Output Specification:

For each test case, print in one line the level order traversal sequence of that tree. All the numbers must be separated by a space, with no extra space at the end of the line.

Sample Input:

9
1 6
2 3
-1 -1
-1 4
5 -1
-1 -1
7 -1
-1 8
-1 -1
73 45 11 58 82 25 67 38 42

Sample Output:

58 25 82 11 38 67 45 73 42

/ **
question mark meaning already given search index position in a binary tree, give a specific value, the required values into binary tree searches, sequence and outputs binary search tree

this question idea is
1. Create two BST
2. after the establishment of the binary search tree, the value of the binary search tree for the insertion of index (as in the sequence of binary search tree is traversed from small to large, so only
the specific value of ascending and the values sorted by the sort preorder inputted to the binary search tree (and depending on the nature of the binary tree root (root) = 0 left index = 2 * index + 1 Right index = 2 * 2 + 2)
will bear the corresponding point vector is fed to the container (the container according to the vector index in ascending order), (but this question needs further descending order by the first height)) in order that the output value of the vector sequence vessel traversal

** /

method one:

Preorder output layer with the index scale:

Specific code:

#include<iostream>
#include<algorithm>
#include<vector>
/**
题意 已经将搜索二叉树的下标索引位置给出，给出具体的值，需要将值填入搜索二叉树中， 并层序输出二叉搜索树
 
 
这道题的思路就是
1.建立二叉搜索树
2.二叉搜索树建立完后，将二叉搜索树的值插入对于索引处（因为二叉搜索树的中序遍历就是从小到大排序，因此只需
将具体的值从小到大排序后 并将排序后的值经中序遍历输入到二叉搜索树中 (并根据二叉树的性质 root(root) = 0 左index = 2 * index + 1 右index = 2 * 2 + 2） 
将结点送入到对应的向量容器中（向量容器根据index从小到排序），（但此题还需要按先将高度从大到小排序）  ） 按顺序输出向量容器中的值 就是层序遍历 
 
 
**/

using namespace std;
struct Node{
	int index, l, r, data, h;
}node[100];
int n, cnt = 0;
vector<int> in;
vector<Node> level;
void inOrder(int root, int index, int h){ //中序遍历 将已有的中序遍历结点依此放入对应搜索BST的索引中 
	if(root == -1) return;
	inOrder(node[root].l, index * 2 + 1, h + 1);
	level.push_back({index, node[root].l, node[root].r, in[cnt++], h});
	inOrder(node[root].r, index * 2 + 2, h + 1); 
}
bool cmp(Node a, Node b){
	if(a.h != b.h)
		return a.h < b.h;
	return a.index < b.index;
}
int main(){
	int l, r, data;
	scanf("%d", &n);
	in.resize(n);
	for(int i = 0; i < n; i++){
		scanf("%d%d", &l, &r);
		node[i].l = l;
		node[i].r = r;
	}
	for(int i = 0; i < n; i++){
		scanf("%d", &data);
		in[i] = data;
	}
	sort(in.begin(), in.end());
	inOrder(0, 0, 0);
	sort(level.begin(), level.end(), cmp);
	for(int i = 0; i < level.size(); i++){
		if(i != 0)
			printf(" ");
		printf("%d", level[i].data);
	}	
	return 0;
}

Method 2:

Application layer preorder traversal queue

Specific code:

#include<iostream>
#include<queue>
#include<vector>
#include<algorithm>
/**
printf("%s%d", k++ == 0 ? "" : " ", n.data); 三目运算符中 第一个输出的是字符,需要在printf表示出来 
**/
using namespace std;
struct Node{
	int data, l, r;
}node[100];
queue<Node> q;
int n, cnt = 0;
vector<int> in;
void BSTorder(int root){
	if(node[root].l != -1) BSTorder(node[root].l);
	node[root].data = in[cnt++];
	if(node[root].r != -1) BSTorder(node[root].r);
}
int main(){
	int l, r, k = 0;
	scanf("%d", &n);
	in.resize(n);
	for(int i = 0; i < n; i++){
		scanf("%d%d", &l, &r);
		node[i].l = l;
		node[i].r = r;
	}
	for(int i = 0; i < n; i++){
		scanf("%d", &in[i]);
	}
	sort(in.begin(), in.end());
	BSTorder(0);
	q.push(node[0]);         //层序遍历 
	while(!q.empty()){
		Node n = q.front(); //取出队首结点 
		q.pop();
		if(n.l != -1)
			q.push(node[n.l]);
		if(n.r != -1)
			q.push(node[n.r]);
		printf("%s%d", k++ == 0 ? "" : " ", n.data);
	}
	
		
	return 0;
}