构建一个完全二叉搜索树04-树6 Complete Binary Search Tree

题目

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

解答

本题是要构建一个完全二叉树，因此可以从搭建一个数组入手，如果起始节点的索引为0，则索引为n的节点的左儿子节点索引为$2\ast n+1$，右儿子节点为$2\ast n+2$。由此可以建立出没有值的树出来。

其次本题给出了所有元素的值，并要求满足二叉搜索树特性。二叉搜索树的中序遍历是从小到大输出的，我们已经有树了，也有值了，因此我们只需要把给出的值从小到大排序放进队列中，再对第一步中得到的树进行中序遍历，把队列的值一个一个放进去，即可完成填树。

最后层序遍历输出只需要按照数组索引顺序依次输出就可以了。

代码如下：

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

/**
 * @author Nino
 */

public class Main {
    static Queue<Integer> queue = new LinkedList<>();
    static int N;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());
        String line = br.readLine();
        String[] lineArr = line.split(" ");
        int[] nums = new int[lineArr.length];
        for (int i = 0; i < lineArr.length; i++) {
            nums[i] = Integer.parseInt(lineArr[i]);
        }
        sort(nums);
        for (int num : nums) {
            queue.add(num);
        }

        Node[] arr = new Node[N];
        int leftIndex = -1;
        int rightIndex = -1;
        for (int i = 0; i < N; i++) {
            arr[i] = new Node(i);
        }
        Node root = arr[0];
        inOrder(root, arr);
        for (int i = 0; i < N; i++) {
            if (i != N - 1) {
                System.out.print(arr[i].toString() + " ");
            } else {
                System.out.println(arr[i]);
            }
        }
    }

    static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    static void sort(int[] arr) {
        int length = arr.length;
        for (int i = 1; i < length; i++) {
            for (int j = i; j > 0 && arr[j] < arr[j-1]; j--) {
                swap(arr, j-1, j);
            }
        }
    }

    static void inOrder(Node node,Node[] arr) {
        if (node == null) {
            return;
        }
        if (leftChildIndex(node.index) < N) {
            node.left = arr[leftChildIndex(node.index)];
        }
        inOrder(node.left,arr);
        node.value = queue.remove();
        if (rightChildIndex(node.index) < N) {
            node.right = arr[rightChildIndex(node.index)];
        }
        inOrder(node.right, arr);
    }


    public static int leftChildIndex(int index) {
        return index * 2 + 1;
    }

    public static int rightChildIndex(int index) {
        return index * 2 + 2;
    }

    static class Node {
        int index;
        int value;
        Node left;
        Node right;

        public Node(int index) {
            this.index = index;
            this.value = -1;
            left = null;
            right = null;
        }

        public Node() {
            value = -1;
            left = null;
            right = null;
        }

        @Override
        public String toString() {
            return String.valueOf(value);
        }
    }
}