1064. Complete 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.

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

注意：

1、这题的关键是要找到每个子树的根节点，由于是完全二叉树，所以可以先计算出左数的结点个数n，那么第n+1个结点就是根节点了，大家可以先画出题例中的树然后归纳找到计算左树结点个数的方法。

2、重建树并bfs层序输出。

代码：

#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#include<cmath>
using namespace std;
struct node
{
	int value;
	node *left;
	node *right;
}root;
vector<int> test;

void build(node *subroot,int start,int end)
{
	subroot->left=NULL;
	subroot->right=NULL;
	if(start==end)
	{
		subroot->value=test[start];
		return;
	}
	//calculate the root's index of the tree
	int n=end-start+1;//number of nodes on this subtree
	int levelnum=log(float(n))/log(2.0)+1;//number of level of this subtree
	int last=n-pow(2.0,levelnum-1)+1;//number of nodes on last level
	int lastmax=pow(2.0,levelnum-1);//max number of node on last level
	int rootindex;//index of the root node
	if(last<=lastmax/2)
		rootindex=start+(n+last-1)/2;
	else
		rootindex=start+pow(2.0,levelnum-1)-1;
	subroot->value=test[rootindex];
	if(rootindex==end)
	{//rootindex==start will not happen
		node *left=new node;
		subroot->left=left;
		build(left,start,rootindex-1);
	}
	else
	{
		node *left=new node;
		node *right=new node;
		subroot->left=left;
		subroot->right=right;
		build(left,start,rootindex-1);
		build(right,rootindex+1,end);
	}
}

void levelprint(node *subroot)
{//bfs
	queue<node*>que;
	que.push(subroot);
	int first=1;
	while(!que.empty())
	{
		if(que.front()->left!=NULL)
			que.push(que.front()->left);
		if(que.front()->right!=NULL)
			que.push(que.front()->right);
		if(first)
			first=0;
		else
			printf(" ");
		printf("%d",que.front()->value);
		que.pop();
	}
}

int main()
{
	int n;
	scanf("%d",&n);
	test.resize(n);
	for(int i=0;i<n;++i)
		scanf("%d",&test[i]);
	sort(test.begin(),test.end());
	build(&root,0,n-1);
	levelprint(&root);
	return 0;
}