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