04-树6 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

解答

//
// Created by world on 2023/3/27.
//
#include "CBTree.hpp"
#include <queue>
#include <algorithm>

int log(int n);

int power(int n);

void findRoot(int low, int high, int *q, int index);

static int *q = nullptr;

int main()
{
//    setbuf(stdout, nullptr);
    int n;
    int d;
    std::cin >> n;
    int *p = new int[n];
    for (int i = 0; i < n; ++i)
    {
        std::cin >> d;
        p[i] = d;
    }
    std::sort(p, p + n);
    q = new int[n];
    findRoot(0, n, p, 0);
    if (q)
    {
        for (int i = 0; i < n - 1; ++i)std::cout << q[i] << ' ';
        std::cout << q[n - 1] << '\n';
    }
    return 0;
}

int log(int n)
{
    if (n <= 0)
        return -1;
    int i = 0, r = 1;
    while (r << 1 <= n)
    {
        r <<= 1;
        i++;
    }
    return i;
}

int power(int n)
{
    int r = 1;
    for (int i = 0; i < n; ++i)
        r <<= 1;
    return r;
}

void findRoot(int low, int high, int *p, int index)
{
    if (low == high)
        return;
    int d = 0, n = high - low;
    int height = log(n + 1);
    int remain = n - power(height) + 1;
    // remain > 2^(h-1) means that the right subtree has leaves.
    d = (remain > power(height - 1) ? power(height - 1) << 1 : remain + power(height - 1)) - 1 + low;
//    std::cout << p[d] << ' ';
    if (q)
        q[index] = p[d];
    findRoot(low, d, p, (index << 1) + 1);
    findRoot(d + 1, high, p, (index << 1) + 2);
}