1064. Complete Binary Search Tree

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

算法思路：先对数组排序（数组从一开始，方便递归），因为是完全二叉搜索树，所以可以根据树的规模判断出左右子树的个数，就可以确定出根节点的值，之后就是递归了（开始忘写递归边界了，之后才想起来）。

之后刷PTA又看到这个题，又写了个链表版本。

数组版本：

#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
const int maxn=1005;
int a[maxn],tree[maxn];
int N;
int leftnumber(int n){
int m=log2(n)+1;//m是左子树元素个数
int k=n+1-(1<<(m-1));
if(k<=(1<<(m-2)))
return k-1+(1<<(m-2));
else
return (1<<(m-1))-1;
}
void solve(int left,int right,int index){
if(index>N) return;
int n=right-left+1;
int m=leftnumber(n);
//printf("%d\n",m);
tree[index]=a[left+m];
solve(left,left+m-1,index*2);//递归左子树
solve(left+m+1,right,index*2+1);//递归右子树
}
int main(){
//freopen("in.txt","r",stdin);
scanf("%d",&N);
for(int i=1;i<=N;i++){
scanf("%d",&a[i]);
}
sort(a+1,a+N+1);
solve(1,N,1);//左右边界，和标号
printf("%d",tree[1]);
for(int i=2;i<=N;i++)
printf(" %d",tree[i]);
printf("\n");
return 0;
}

链表版本：

#include<cstdio>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn=1005;
typedef struct TreeNode TreeNode;
struct TreeNode{
int val;
struct TreeNode *left,*right;
TreeNode():left(NULL),right(NULL){};
};
int N,a[maxn];
int find_root(int num){
int level,m,x;
level=log2(num)+1;
x=num+1-(1<<(level-1));
if(x<=(1<<(level-2)))
return x-1+(1<<(level-2));
return (1<<(level-1))-1;
}
TreeNode* BuildTree(int left,int right,int index){
if(index>N){
return NULL;
}
TreeNode *root=new TreeNode();
int pos=find_root(right-left+1);
root->val=a[left+pos];
//printf("%d ",left);
//printf("%d\n",pos);
root->left=BuildTree(left,left+pos-1,2*index);
root->right=BuildTree(left+pos+1,right,2*index+1);
return root;
}
void pre_order(TreeNode *root){
if(root==NULL)
return;
printf("%d ",root->val);
pre_order(root->left);
pre_order(root->right);
}
void bfs(TreeNode *root){
TreeNode *t;
queue<TreeNode*>q;
q.push(root);
printf("%d",root->val);
while(!q.empty()){
t=q.front();
q.pop();
if(t->left){
q.push(t->left);
printf(" %d",t->left->val);
}
if(t->right){
q.push(t->right);
printf(" %d",t->right->val);
}
}
printf("\n");
}
int main(){
//freopen("in.txt","r",stdin);
scanf("%d",&N);
for(int i=0;i<N;i++)
scanf("%d",&a[i]);
sort(a,a+N);
TreeNode *root=BuildTree(0,N-1,1);
//pre_order(root);
bfs(root);
return 0;
}