#include <stdio.h>
#include <stdlib.h>
// Структура узла дерева
typedef struct Tree {
int num;
struct Tree *left, *right;
} Tree;
// Функции прототипы
void AddNode(int x, Tree **MyTree);
void ShowTree(Tree *MyTree, int level);
int CountNodesAtLevel(Tree *MyTree, int level);
void DeleteTree(Tree **MyTree);
int main() {
Tree *root = NULL;
int n; // уровень для подсчёта
int count; // количество элементов в последовательности
// Ввод количества элементов
printf("Введите количество элементов: ");
scanf("%d", &count);
printf("Введите элементы последовательности:\n");
for (int i = 0; i < count; i++) {
int val;
scanf("%d", &val);
AddNode(val, &root);
}
printf("\nДерево:\n");
ShowTree(root, 0);
printf("\nВведите уровень для подсчёта узлов: ");
scanf("%d", &n);
int result = CountNodesAtLevel(root, n);
printf("Число узлов на уровне %d: %d\n", n, result);
// Освобождение памяти
DeleteTree(&root);
return 0;
}
// Добавление узла в дерево
void AddNode(int x, Tree **MyTree) {
if (*MyTree == NULL) {
*MyTree = (Tree*) malloc(sizeof(Tree));
(*MyTree)->num = x;
(*MyTree)->left = NULL;
(*MyTree)->right = NULL;
} else {
if (x < (*MyTree)->num) {
AddNode(x, &(*MyTree)->left);
} else if (x > (*MyTree)->num) {
AddNode(x, &(*MyTree)->right);
}
// Если x равно текущему значению — ничего не делаем
}
}
// Вывод дерева с отступами по уровням
void ShowTree(Tree *MyTree, int level) {
if (MyTree != NULL) {
ShowTree(MyTree->left, level + 1);
for (int i = 0; i < level; i++)
printf(" "); // отступы для визуализации уровня
printf("%d\n", MyTree->num);
ShowTree(MyTree->right, level + 1);
}
}
// Подсчет количества узлов на заданном уровне
int CountNodesAtLevel(Tree *MyTree, int level) {
if (MyTree == NULL)
return 0;
if (level == 0)
return 1;
return CountNodesAtLevel(MyTree->left, level - 1) + CountNodesAtLevel(MyTree->right, level - 1);
}
// Освобождение памяти дерева
void DeleteTree(Tree **MyTree) {
if (*MyTree != NULL) {
DeleteTree(&(*MyTree)->left);
DeleteTree(&(*MyTree)->right);
free(*MyTree);
*MyTree = NULL;
}
}
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