PAT A 1099. Build A Binary Search Tree (30)

最新推荐文章于 2022-11-16 15:14:48 发布

原创最新推荐文章于 2022-11-16 15:14:48 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#PAT #C++ #算法

PAT 专栏收录该内容

99 篇文章

订阅专栏

本文详细介绍了如何使用递归方法计算二叉查找树的子树大小，对输入序列进行排序，然后根据左右子树的大小递归构建树。最后通过广度优先搜索（BFS）输出层序遍历的结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

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;
}