1115 Counting Nodes in a BST (30分)_hight counting node-优快云博客

本文链接：https://blog.youkuaiyun.com/zbchenchanghao/article/details/104189635

本文介绍了一种算法，用于在构建的二叉搜索树中计算最低两层的节点总数。通过递归定义的二叉搜索树（BST），确保左子树的所有节点键小于等于根节点键，右子树的所有节点键大于根节点键，且左右子树也必须是二叉搜索树。文章详细描述了如何插入一系列数字到初始空树，并统计结果树的底层节点数量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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 or equal to the node's key.
The right subtree of a node contains only nodes with keys greater than the node's key.
Both the left and right subtrees must also be binary search trees.

Insert a sequence of numbers into an initially empty binary search tree. Then you are supposed to count the total number of nodes in the lowest 2 levels of the resulting tree.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤1000) which is the size of the input sequence. Then given in the next line are the Nintegers in [−10001000] which are supposed to be inserted into an initially empty binary search tree.

Output Specification:

For each case, print in one line the numbers of nodes in the lowest 2 levels of the resulting tree in the format:

n1 + n2 = n

where n1 is the number of nodes in the lowest level, n2 is that of the level above, and n is the sum.

Sample Input:

9
25 30 42 16 20 20 35 -5 28

Sample Output:

2 + 4 = 6

#include<iostream>

#include<cstring>
#include<vector>
#include<queue>
using namespace std;
struct node
{
    int data;
    node * lchild;
    node * rchild;
};
int a[1001] = {0};
node * creat_tree(node * root, int data){

    if(root == NULL){
        
        root = new node();
        root -> data = data;
        root -> lchild = root -> rchild = NULL;
    }else if (data <= root -> data)
    {
        root -> lchild = creat_tree(root -> lchild, data);
        
    }else
    {
        root -> rchild = creat_tree(root -> rchild, data); 
        
    }

    return root;

}
void level_order(node * tree){
    queue<node *> que;
    que.push(tree);
    int hight = 0;
    while (!que.empty())
    {
        int z = que.size();
        a[hight] = z;
            while (z--)
            {
                if(que.front() -> lchild != NULL){
                    que.push(que.front() -> lchild);
                }
                if(que.front() -> rchild != NULL){
                    que.push(que.front() -> rchild);
                }
                que.pop();
            }
            hight++;
            
    
    }
    

}

int main(){
    int n;
    cin >> n;
    vector<int> vec(n);
    node * t = NULL;
    for(int i = 0; i < n; i++){

        scanf("%d", &vec[i]);
        
        t = creat_tree(t, vec[i]);

    }

    level_order(t);
    int flag;
    for(int i = 0; i < 1000; i++){
        if(a[i]){
           
            flag = i;
        }
    }
    printf("%d + %d = %d\n", a[flag], a[flag - 1], a[flag] + a[flag - 1]);
    return 0;

}