题目详情：

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

简单翻译：

给一串构成树的序列，已知该树是完全二叉搜索树，求它的层序遍历的序列

主要思路：

1. 因为二叉搜索树的中序满足：是一组序列的从小到大排列，所以只需将所给序列排序即可得到中序数组in
2. 假设把树按从左到右、从上到下的顺序依次编号，根节点为0，则从根结点root = 0开始中序遍历，root结点的左孩子下标是root*2+1，右孩子下标是root*2+2

递归的终止条件是下标比节点数目大

递归时也按中序遍历

单层处理逻辑是将已知的中序输出结果数组里对应位置的数字赋给通过从0~n -1下标中序遍历的level数组
因为是中序遍历，所以遍历结果与中序数组in中的值从0开始依次递增的结果相同，即in[t++]（t从0开始），将in[t++]赋值给level[root]数组
3. 因为树是按从左到右、从上到下的顺序依次编号的，所以level数组从0到n-1的值即所求的层序遍历的值，输出level数组即可

如下图解释

 

代码实现：

/*
将读入的数据按从小到大排序，构成中序遍历结果
利用规律递归
递归返回值返回到层序遍历数组中
*/
#include <stdio.h>  
#define MAX_SIZE 1005
int Inorder[MAX_SIZE];
int Levelorder[MAX_SIZE];
int N;
int Ptr = 0;
/*从小到大排序*/
void Sort(int nodeNum) {
    for(int i = 0; i < nodeNum; i++) {
        for(int j = i; j < nodeNum; j++) {
            if(Inorder[i] > Inorder[j]) {
                int tmp = Inorder[i];
                Inorder[i] = Inorder[j];
                Inorder[j] = tmp;
            }
        }
    }
    return;
}
/*递归建树*/
void BuildTree(int root) {
    if(root >= N) {
        return;
    }

    BuildTree(root * 2 + 1);
    Levelorder[root] = Inorder[Ptr++];
    BuildTree(root * 2 + 2);
    return;
}
/*主函数*/
void MainFunction() {
    scanf("%d", &N);
    for(int i = 0; i < N; i++) {
        scanf("%d", &(Inorder[i]));
    }
    Sort(N);
    BuildTree(0);
    for(int i = 0; i < N; i++) {
        if(i != N - 1) {
            printf("%d ", Levelorder[i]);
        }
        else {
            printf("%d", Levelorder[i]);
        }
    }
    return;
}
int main() {
    MainFunction();
    return 0;
}