PAT A 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
  

  
  

  根据已知结构的二叉查找树，将数据填入树中，输出层序遍历。

  步骤：

  1、递归统计各个子树的左右子树的大小

  2、对输入的数值排序

  3、由根向叶根据左右子树大小，递归求得相应位置对应的值，并构建树

  4、bfs层序遍历输出

  
  

  代码：

  #include <iostream>
  #include <algorithm>
  #include <vector>
  #include <deque>
  using namespace std;
  
  struct node	//树中的点
  {
  	int val;	//值
  	node *left,*right;	//左右子节点
  	node(int v):val(v),left(NULL),right(NULL){}
  };
  
  int cal_sub(int id,vector<int> &sub,vector<int> &child);	//计算相应id节点的左右子树大小
  node *build(int id,int begin,vector<int> &child,vector<int> &sub,vector<int> &val);	//构造树
  
  int main()
  {
  	int n;
  	cin>>n;
  
  	vector<int> child(2*n,-1);	//i*2,i*2+1,分别为节点i的两个孩子
  	vector<int> num_sub(2*n,-1);	//i*2,i*2+1,分别为节点i的两个子树的大小
  	for(int i=0;i<n;i++)
  		cin>>child[2*i]>>child[2*i+1];
  	cal_sub(0,num_sub,child);	//递归计算子树的大小
  
  	vector<int> val(n);		//输入的序列
  	for(int i=0;i<n;i++)
  		cin>>val[i];
  	sort(val.begin(),val.end());	//排序
  
  	node *root=build(0,0,child,num_sub,val);	//树，构造
  	deque<node*> queue(1,root);	//bfs队列
  	node *tnp1;
  	while(!queue.empty())	//bfs
  	{
  		tnp1=queue.front();
  		queue.pop_front();
  		if(tnp1!=NULL)
  		{
  			if(tnp1->left!=NULL)
  				queue.push_back(tnp1->left);
  			if(tnp1->right!=NULL)
  				queue.push_back(tnp1->right);
  			cout<<tnp1->val;
  			if(!queue.empty())
  				cout<<" ";
  		}
  	}
  
  	return 0;
  }
  
  int cal_sub(int id,vector<int> &sub,vector<int> &child)	//id，子树大小存储序列，左右孩子信息
  {
  	if(id==-1)
  		return 0;
  	if(sub[2*id]==-1)
  	{
  		sub[2*id]=cal_sub(child[id*2],sub,child);
  		sub[2*id+1]=cal_sub(child[id*2+1],sub,child);
  	}
  	return sub[2*id]+sub[2*id+1]+1;
  }
  
  //不构造树，用序列来存储其实就可以了……id，相应子树的最小元素在整个树中的位置，节点孩子序列，子树大小序列，值序列。
  node *build(int id,int begin,vector<int> &child,vector<int> &sub,vector<int> &val)
  {
  	if(id==-1)
  		return NULL;
  	node *root=new node(val[begin+sub[id*2]]);
  	root->left=build(child[id*2],begin,child,sub,val);
  	root->right=build(child[id*2+1],begin+sub[id*2]+1,child,sub,val);
  	return root;
  }