pat04-树8. Complete Binary Search Tree (30)

04-树8. Complete Binary Search Tree (30)

时间限制

100 ms

内存限制

65536 kB

代码长度限制

8000 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

---

提交代码

 

 

 

解法一：

数组做法：

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<queue>
#include<vector>
#include<cmath>
#include<string>
using namespace std;
int tree[1005],endtree[1005];
int GetLeftLength(int n){
    int h=log(n+1)/log(2);//除去最后一排的元素
    int x=n+1-pow(2,h);
    if(x>=pow(2,h-1)){
        x=pow(2,h-1);
    }
    return x+pow(2,h-1)-1;
}
void solve(int left,int right,int root){
    int n=right-left+1;
    if(!n) return;
    int l=GetLeftLength(n);
    endtree[root]=tree[left+l];
    solve(left,left+l-1,root*2+1);
    solve(left+l+1,right,root*2+2);
}
int main(){
    //freopen("D:\\INPUT.txt","r",stdin);
    int n;
    scanf("%d",&n);
    int i;
    for(i=0;i<n;i++){
        scanf("%d",&tree[i]);
    }
    sort(tree,tree+n);
    solve(0,n-1,0);
    printf("%d",endtree[0]);
    for(i=1;i<n;i++){
        printf(" %d",endtree[i]);
    }
    printf("\n");
    return 0;
}

 

 

 

方法二：

链表做法：

递归建树的思想：想找出当前的中间大的树，作为当前树根，然后遍历左子树，右子树，最后对所建的BST进行层序遍历。

当前元素总个数为n，则层数k为ceil(log2(n+1))：

1.n>=3*2^(k-2)，即查找树的最后一个元素位于根的右子树部分。则此时右子树有 n-(3*2^(k-2)-1)+2^(k-2)-1 个元素，左边有 n-右子树元素个数-1=n-(n-(3*2^(k-2)-1)+2^(k-2)-1)-1=2^(k-1)-1个元素，则中间元素下标为 2^(k-1)-1 （从0开始）。

2.n<3*2^(k-2)，即查找树的最后一个元素位于根的左子树部分。则此时右子树有 2^(k-2)-1 个元素，左边有 n-右子树元素个数-1=n-(2^(k-2)-1)-1=n-2^(k-2) 个元素，则中间元素下标为 n-2^(k-2) （从0开始）。

 

#include<cstdio>
#include<functional>
#include<queue>
#include<cmath>
#include<algorithm>
#include<iostream>
using namespace std;
int mem[1005];
struct node{
    int v;
    node *l,*r;
    node(){
        l=r=NULL;
    }
};
void CBTBuild(int *mem,int n,int mid,node *&p){
    //q.push(mem[mid]);
    p=new node();
    p->v=mem[mid];
    //cout<<mem[mid]<<endl;

    if(mid-1>=0){//left tree
        int nn=mid;
        int k=ceil(log(nn+1)/log(2));
        if(nn>=3*pow(2,k-2)){//超过一半
            CBTBuild(mem,nn,pow(2,k-1)-1,p->l);
        }
        else{//未超过一半
            CBTBuild(mem,nn,nn-pow(2,k-2),p->l);
        }
    }
    if(mid+1<n){//right tree
        int nn=n-(mid+1);
        int k=ceil(log(nn+1)/log(2));
        if(nn>=3*pow(2,k-2)){//超过一半
            CBTBuild(mem+mid+1,nn,pow(2,k-1)-1,p->r);
        }
        else{//未超过一半
            CBTBuild(mem+mid+1,nn,nn-pow(2,k-2),p->r);
        }
    }
}
int main(){
    //freopen("D:\\INPUT.txt","r",stdin);
    int n,i,j,k;
    queue<node> q;
    scanf("%d",&n);
    for(i=0;i<n;i++){
        scanf("%d",&mem[i]);
    }
    sort(mem,mem+n);

    /*for(i=0;i<n;i++){
        cout<<mem[i]<<endl;
    }*/
    node *h;
    k=ceil(log(n+1)/log(2));
    if(n>=3*pow(2,k-2)){//超过一半
        CBTBuild(mem,n,pow(2,k-1)-1,h);

        //cout<<mem[int(pow(2,k-1)-1)]<<endl;

    }
    else{//未超过一半
        CBTBuild(mem,n,n-pow(2,k-2),h);

        //cout<<mem[int(n-pow(2,k-2))]<<endl;

    }
    int top;
    node p=*h;
    q.push(p);
    printf("%d",p.v);
    while(!q.empty()){
        p=q.front();
        q.pop();
        if(p.l!=NULL){
            q.push(*(p.l));
            printf(" %d",p.l->v);
        }
        if(p.r!=NULL){
            q.push(*(p.r));
            printf(" %d",p.r->v);
        }
    }
    printf("\n");
    return 0;
}