PAT 1064. Complete Binary Search Tree (30)

1064. Complete Binary Search Tree (30)

时间限制

100 ms

内存限制

65536 kB

代码长度限制

16000 B

判题程序

Standard

作者

CHEN, Yue

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.

A Complete Binary Tree (CBT) is a tree that is completely filled, with the possible exception of the bottom level, which is filled from left to right.

Now given a sequence of distinct non-negative integer keys, a unique BST can be constructed if it is required that the tree must also be a CBT. You are supposed to output the level order traversal sequence of this BST.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (<=1000). Then N distinct non-negative integer keys are given in the next line. All the numbers in a line are separated by a space and are no greater than 2000.

Output Specification:

For each test case, print in one line the level order traversal sequence of the corresponding complete binary search tree. All the numbers in a line must be separated by a space, and there must be no extra space at the end of the line.

Sample Input:

10
1 2 3 4 5 6 7 8 9 0

Sample Output:

6 3 8 1 5 7 9 0 2 4

---

看到这道题第一反应是用常规的方法构建出一个CBT，不过然后一想觉得，只是做题而已，没必要真的构建一个树出来。于是就采用计算左子树和右子树节点各数然后递归的方式，直接记录每个点在哪一层并输出。

计算方法是先算右子树节点数：给定一个起点（begin)和终点(end)，先算出长度并减一（size），然后除二得到half，然后根据二叉树的性质算出右子树最多可以构建出几层的CBT(num)，那么首先左子树也可以构建出相同层数的CBT，于是size-num*2就是剩余的节点数，pow(2,i)就是单个子树下一层最多能存放的节点数，那么size-num*2-pow(2,i)就是要放到右子树中的多余节点。于是就可以算出左子树和右子树各自的节点数了。 代码如下： 

#include <iostream>
#include <algorithm>
#include <cmath>
#include <set>
#include <vector>
#include <map>
#include <cstring>
using namespace std;
vector<int> ori;
map<int,set<int> > levelorder;
void build(int begin,int end,int level)
{
	if(begin>end)
		return;
	int size=(end-begin);
	int half=size/2;
	int i=0,num=0,right=0;
	while(true)
	{
		num+=pow(2,i);
		if(num-half>0)
		{
			num-=pow(2,i);
			break;
		}
		else
			i++;
	}
	int rem=size-num*2-pow(2,i);
	if(rem>0)
		right=num+rem;
	else
		right=num;
	int rightbegin=end+1-right;
	int leftend=rightbegin-2;
	int mid=rightbegin-1;
	if(levelorder.count(level)<=0)
	{
		set<int> temp;
		temp.insert(ori[mid]);
		levelorder[level]=temp;
	}
	else
		levelorder[level].insert(ori[mid]);
	build(begin,leftend,level+1);
	build(rightbegin,end,level+1);
}
int main()
{
	int N,i;
	cin>>N;
	while(N--)
	{
		int temp;
		cin>>temp;
		ori.push_back(temp);
	}
	sort(ori.begin(),ori.end());
	build(0,ori.size()-1,1);
	map<int,set<int> >::iterator it=levelorder.begin();
	set<int>::iterator it2=it->second.begin();
	cout<<*it2;
	it2++;
	while(it2!=it->second.end())
	{
		cout<<" "<<*it2;
		it2++;
	}
	for(++it;it!=levelorder.end();it++)
	{
		set<int>::iterator it2;
		for(it2=it->second.begin();it2!=it->second.end();it2++)
			cout<<" "<<*it2;
	}
}