PAT1064 完全二叉搜索树

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

题目大意：

给你一个序列，她说这个序列可以构建一棵唯一的完全二叉搜索树，也就是它既是二叉搜索树，也是完全二叉树。让我们输出这个 完全二叉搜索树的层序遍历序列。

思路分析：

说起完全二叉树，我们知道堆就是一种完全二叉树，一般存储堆都是使用数组存储。因此，这个地方我们也是可以用数组来存储这棵树的。其次我们知道，二分搜索树的中序遍历是有序的，一般情况就是 递增的。因此我们把输入序列进行排序就可以得到CBT 的中序序列。 然后我们就对CBT 进行一次中序遍历，然后把中序序列按照节点遍历的顺序填进去，就可以得到一个由数组存放的 CBT.

由于用数组存放完全二叉树，就是按照层序进行存放的，因此我们把填充好的CBT 数组顺序输出就是层序遍历序列。

在数组中，如果一个节点在数组中的下标为 index (下标范围 1—N ) ，那么它的左孩子 的下标就是 index * 2 右孩子的下标范围就是 index*2 + 1 。 什么时候走到一个空节点呢？ index > N 说明这个节点就是一个空节点。

多说一句，什么时候走到一个叶子节点呢？ index *2 >N,也就是这个节点没有左孩子。在完全二叉树中没有左孩子也就没有右孩子。

完整代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

//10
//1 2 3 4 5 6 7 8 9 0
public class P1064 {
    static  int nodeNum  ;
    static  int[] cbt ,orginal;
    static  int cnts =1 ; // 中序遍历存放数据 我们要一个一个顺序地把排序过的orgial数组元素放到CBT中
    public  static  void  main(String [] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)) ;
        nodeNum = Integer.parseInt(bf.readLine()) ;
        orginal = new int[nodeNum+1] ;  // 节点存放范围【0...nodeNum】
        cbt = new int[nodeNum+1] ;
        String [] data = bf.readLine().split(" ") ;
        for(int i = 1 ;i<= nodeNum ;i++)
            orginal[i] = Integer.parseInt(data[i-1]) ; // 这里是i-1因为在data中数据下标从0开始
        Arrays.sort(orginal);
        InorderTravel(1);
        LevelOrder();

    }

    //中序遍历，在遍历的途中做一件事，把中序数据填入到CBT数组中
    static  void  InorderTravel(int index ){
        if(index > nodeNum){
            return;
        }
        InorderTravel(index*2 ); // 左子树 2*index
        cbt[index] = orginal[cnts++] ;
        InorderTravel(index*2+1); // 右子树 2*index +1
    }
    // 层序遍历 也就是顺序输出
    static  void  LevelOrder(){
		 for(int i = 1 ;i<=nodeNum ;i++){

            System.out.print(cbt[i]);
            if(i!=nodeNum)
                System.out.print(" ");

        }
    }
}