Министерство образования республики Молдова

Технический университет Молдовы

Кафедра «Вычислительной техники, информатики и микроэлектроники »

Отчёт
Лабораторная работа № 5
Тема: Алгоритмы обработки бинарных деревьев

выполнил студент гр. SI-222 Carasev I.

проверил: Mititelu V.

Кишинёв 2023
Цель: Программирование алгоритмов обработки бинарных деревьев для реализации и
использования основных операций на языке C.

Задание (Вариант 3):

Составить три файла на языке Си для реализации и использования абстрактного типа
данных «Бинарное дерево»:
1. Заголовочный файл с расширением .h для описания структуры данных бинарного
дерева а также для прототипов функций, обеспечивающих операции его обработки.
2. Файл с расширением «.c» или «.cpp» для определений функций (текстов функций),
объявленных в заголовочном файле.
3. Файл пользователя - функцию mаin () для обработки бинарных деревьев с выводом на
экран меню операций (минимум- первые три), а именно:
1. создание и ввод с клавиатуры элементов бинарного дерева
2. ввод с клавиатуры элементов дерева
3. вывод на экран элементов дерева
4. удаление элементов дерева
5. добавление элемента в дерево
6. поиск элемена в дерево
7. изменение полей определенного элемента дерева
8. определение глубины дерева
9. сортировка элементов дерева
10.определние максимального/ минимального элемента дерева
11.освобождение памяти, выделенной для дерева
0. выход из программы.
Краткое изложение темы:
Бинарное дерево - это структура данных, которая состоит из узлов и связей между ними.
Каждый узел может иметь не более двух потомков, которые сами являются узлами
дерева. Бинарные деревья используются в различных областях, таких как поиск,
сортировка, компьютерная графика и др. Основные операции, которые можно
реализовать для бинарных деревьев, включают вставку новых узлов, поиск узлов,
удаление узлов, обход дерева в глубину или ширину и др. Реализация этих операций на
языке C требует знания основных конструкций языка, таких как указатели, структуры,
функции и операторы управления потоком. При программировании алгоритмов
обработки бинарных деревьев на языке C важно учитывать особенности данного типа
данных, такие как правила бинарного дерева и его балансировка. Для решения этих
проблем можно использовать различные алгоритмы и структуры данных, такие как AVL-
деревья, красно-черные деревья и B-деревья. В целом, программирование алгоритмов
обработки бинарных деревьев на языке C является важной темой для разработчиков
программного обеспечения, которые работают с большим объемом данных и нуждаются
в эффективных алгоритмах для их обработки.

Код программы:

Файл (его название совпадает с название программы), в котором находится основной

блок main, содержит следующий код:
#include <stdio.h>
#include "function.c"

int main() {
Tree *tree_1 = NULL;
int choice = -1, stds_nmbr = 0, buffer = 0;

while (choice) {
printf(" 1 - Create tree and input elements.\n 2 - Add element.\n 3 - Print tree (vsd).\n 4 - Draw a tree (only id).\n");
 printf(" 5 - Clear tree.\n 6 - Search element.\n 7 - Edit element.\n 8 - Search min/max element.\n");
printf(" 9 - Free tree.\n 0 - Exit.\n\n");
scanf("%d", &choice);
switch(choice) {
case 1:
if(tree_1) {
printf("\nError: tree already exists.\n");
break;
}
tree_1 = create_tree();
if (!tree_1) {
printf("\nError: Failed allocation.\n");
break;
}
printf("\nInput nr of elements: ");
scanf("%d", &buffer);
for (int i = 0; i < buffer; i++) {
add_element(tree_1);
printf("\n");
stds_nmbr++;
}
break;
case 2:
add_element(tree_1);
break;
case 3:
print_vsd(tree_1);
break;
case 4:
print_tree(tree_1);
break;
case 5:
if (tree_1->head) clear_tree(tree_1);
break;
case 6:
printf("\nInput id (integer number): ");
scanf("%d", &buffer);
print_node(search_node(tree_1, buffer));
break;
case 7:
printf("\nInput id (integer number): ");
scanf("%d", &buffer);
edit_element(tree_1, buffer);
break;
case 8:
search_min_max_element(tree_1);
break;
case 9:
if (tree_1) {
if (tree_1->head) clear_tree(tree_1);
free(tree_1);
tree_1 = NULL;
}
stds_nmbr = 0;
break;
case 0:
if (tree_1) {
if (tree_1->head) clear_tree(tree_1);
free(tree_1);
tree_1 = NULL;
}
break;
default:
break;
}
system("pause");
system("cls");
}
return 0;
}
Файл .h:

typedef struct Data {

char name[50];
char address[256];
int phone;
int category;
int capacity;
} Data;

typedef struct Node {

int id;
struct Data *data;
struct Node *right;
struct Node *left;
} Node;

typedef struct Tree {

Node *head;
} Tree;

//Help function
void __help_clear_tree(Node *head);
void __help_add_element(Node *head, Node *current, Node *tmp);
Node *__help_search_node(Node *current, int id);
void __help_print_tree(Node* node, int level, int dir);
void __help_print_vsd(Node *node);
int __help_search_depth(Node *node, int count);

//Function
Tree *create_tree();
Node *create_node ();
void print_node(Node *node);
void add_element(Tree *tree);
Node *search_node(Tree *tree, int id);
void clear_tree(Tree *tree);
void print_tree(Tree* tree);
void print_vsd(Tree *tree);
void edit_element(Tree *tree, int id);
int search_depth(Tree *tree);
void search_min_max_element(Tree *tree);

Файл содержащий реализацию функций, а также структуры:

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include <wchar.h>
#include <windows.h>
#include <wctype.h>
#include <locale.h>
#include "header.h"

Tree *create_tree() {
Tree *tree = malloc(sizeof(Tree));
tree->head = NULL;
return tree;
}

Node *create_node () {
Node *tmp = malloc(sizeof(Node));
if(!tmp) {
printf("\nError.\n");
return NULL;
}
 tmp->data = malloc(sizeof(Data));
if(!tmp->data) {
printf("\nError.\n");
return NULL;
}
if (tmp) {
printf("Input id: ");
scanf("%d", &tmp->id);
printf("Name: ");
scanf("%s", tmp->data->name);
fflush(stdin);
printf("Adress: ");
scanf("%s", tmp->data->address);
fflush(stdin);
printf("Phone: ");
scanf("%d", &tmp->data->phone);
printf("Category: ");
scanf("%d", &tmp->data->category);
printf("Capacity: ");
scanf("%d", &tmp->data->capacity);
tmp->left = NULL;
tmp->right = NULL;
return tmp;
}
return NULL;
}

void print_node(Node *node) {

if (node) {
printf("\nid: %d\n", node->id);
printf("Name: %s\n", node->data->name);
printf("Adress: %s\n", node->data->address);
printf("Phone: %d\n", node->data->phone);
printf("Category: %d\n", node->data->category);
printf("Capacity: %d\n", node->data->capacity);
}
}

void __help_add_element(Node *head, Node *current, Node *tmp) {

if (current->id > tmp->id) {
if (current->left) __help_add_element(head, current->left, tmp);
else current->left = tmp;
}
else if (current->id < tmp->id) {
if (current->right) __help_add_element(head, current->right, tmp);
else current->right = tmp;
}
else {
printf("\nError: This id already exists\nplease enter another one: ");
scanf("%d", &tmp->id);
__help_add_element(head, head, tmp);
}
}

void add_element(Tree *tree) {

if (tree) {
if (tree->head) {
__help_add_element(tree->head, tree->head, create_node());
return;
}
tree->head = create_node();
return;
}
printf("\nError: Tree not initialized.\n");
}

void __help_print_tree(Node* node, int level, int dir) {

if (node == NULL) return;
__help_print_tree(node->right, level + 1, 1);
for (int i = 0; i < level; i++) {
printf(" ");
 }
if (dir == 1) printf("/%d\n", node->id);
if (dir == -1) printf("%c%d\n",92, node->id);
if (dir == 0) printf("*%d\n", node->id);
__help_print_tree(node->left, level + 1, -1);
}

void print_tree(Tree* tree) {

if (tree) {
if (tree->head) {
__help_print_tree(tree->head, 0, 0);
return;
}
printf("\nError: The tree is empty.\n");
return;
}
printf("\nError: Tree not initialized.\n");
return;
}

Node *__help_search_node(Node *current, int id) {

if (current->id > id) {
if (current->left) return __help_search_node(current->left, id);
}
else if (current->id < id) {
if (current->right) return __help_search_node(current->right, id);
}
else if (current->id == id) return current;

printf("\nError: Element not fount.\n");

return NULL;
}

Node *search_node(Tree *tree, int id) {

if (tree) {
if (tree->head) {
return __help_search_node(tree->head, id);
}
printf("\nError: The tree is empty.\n");
return NULL;
}
printf("\nError: Tree not initialized.\n");
return NULL;
}

void __help_clear_tree(Node *head){

if (head) {
__help_clear_tree(head->left);
__help_clear_tree(head->right);

free(head->data);
free(head);
head = NULL;
}
}

void clear_tree(Tree *tree) {

if (tree) {
__help_clear_tree(tree->head);
tree->head = NULL;
return;
}
printf("\nError: Tree not initialized.\n");
}

void __help_print_vsd(Node *head) {

if (head) {
print_node(head);

__help_print_vsd(head->left);
__help_print_vsd(head->right);
 }
}
void print_vsd(Tree *tree) {
if (tree) {
if (tree->head) {
__help_print_vsd(tree->head);
return;
}
printf("\nError: The tree is empty.\n");
return;
}
printf("\nError: Tree not initialized.\n");
return;
}

void edit_element(Tree *tree, int id) {

if (tree) {
if (tree->head) {
printf("\nStart edit:\n");
Node *tmp = search_node(tree, id);
printf("Name: ");
scanf("%s", tmp->data->name);
fflush(stdin);
printf("Adress: ");
scanf("%s", tmp->data->address);
fflush(stdin);
printf("Phone: ");
scanf("%d", &tmp->data->phone);
printf("Category: ");
scanf("%d", &tmp->data->category);
printf("Capacity: ");
scanf("%d", &tmp->data->capacity);
return;
}
printf("\nError: The tree is empty.\n");
return;
}
printf("\nError: Tree not initialized.\n");
return;
}

int __help_search_depth(Node *head, int count) {

if (head) {
int left_dpt = __help_search_depth(head->left, count+1);
int right_dpt = __help_search_depth(head->right, count+1);
if (left_dpt > right_dpt) return left_dpt;
return right_dpt;
}
else return count-1;
}

int search_depth(Tree *tree) {

if (tree) {
if (tree->head) {
return __help_search_depth(tree->head, 0);
}
printf("\nError: The tree is empty.\n");
return -1;
}
printf("\nError: Tree not initialized.\n");
return -1;
}

void search_min_max_element(Tree *tree) {

if (tree) {
if (tree->head) {
Node *curr = tree->head;
while (curr->left) {
curr = curr->left;
}
 printf("\nMin element:\n");
print_node(curr);
curr = tree->head;
while (curr->right){
curr = curr->right;
}
printf("\nMax element:\n");
print_node(curr);
return;
}
printf("\nError: The tree is empty.\n");
return;
}
printf("\nError: Tree not initialized.\n");
return;
}

Файлы находятся в папке с самой программой:

Результаты работы программы:

Меню
Инициализация и ввод

Вывод дерева(VSD)

Поиск элемента
Добавление элементов

Нарисованное дерево

Изменение элемента
Элемент до изменения

Поиск максимального и минимального элементов

Дерево после очистки

Выводы:
Я научился программированию алгоритмов бинарных деревьев для реализации и
использования основных операций на языке C.

Литература:
Основной учебник курса это ПОЛЯКОВ "Программирование на языке Си. "
2009 г.