ZJU PTA ds 7-1 Complete Binary Search Tree

_Song_

于 2022-01-12 14:55:14 发布

阅读量547

点赞数

分类专栏：数据结构和算法-ds 文章标签：数据结构 complete tree binary tree

本文链接：https://blog.csdn.net/s_w_s_/article/details/122453522

版权

数据结构和算法-ds 专栏收录该内容

19 篇文章 2 订阅

订阅专栏

7-1 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

#include <stdio.h>
#include <math.h>
#include <string.h>

int cmpfunc(const void * a, const void * b);
void BuildTree(int left, int right, int rootPos);
void InOrderTraversal(int *tree, int n);
int key[1001];
int tree[1001];

int main()
{
    int n;
    scanf("%d", &n);


    for (int i = 1; i <= n; i++) {
        scanf("%d", &key[i]);
    }
    // 快速排序
    qsort(key + 1, n, sizeof(key[0]), cmpfunc);

    // 建立完全二叉搜索树
    BuildTree(1, n, 1);
    
    InOrderTraversal(tree, n);

    return 0;
}

void BuildTree(int left, int right, int rootPos)
{
    if (left > right) {
        return ;
    }
//	printf("%d %d %d ",left, right, rootPos);// debug
    int nodeSum = right - left + 1;
    int height = (int)(log(nodeSum) / log(2)) + 1;
//    printf("%d ", height);// debug
    int count1 = 1 + nodeSum - (int)pow(2, height - 1);
    if (count1 > (int)pow(2, height - 2)) {
    	count1 = (int)pow(2, height - 2);
	}
    int count2 = ((int)pow(2, height - 1) - 1) / 2;
    int leftNodeSum = count1 + count2;
//    printf("%d ", leftNodeSum);// debug
    tree[rootPos] = key[left + leftNodeSum];
	
    BuildTree(left, left + leftNodeSum - 1, rootPos * 2);
    BuildTree(left + leftNodeSum + 1, right, rootPos * 2 + 1);
}

void InOrderTraversal(int *tree, int n)
{
    for (int i = 1; i <= n; i++) {
        if (i == 1) {
            printf("%d", tree[i]);
        }
        else {
            printf(" %d", tree[i]);
        }
    }
}

// 比较函数，升序排列
int cmpfunc(const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}