Ministerul Educației și

Cercetării al Republicii
Moldova
Universitatea Tehnică a
Moldovei
Facultatea Calculatoare Informatică și
Microelectronică Departamentul Ingineria
Software și Automatică

RAPORT
la lucrarea de laborator
nr. 3 Structuri de Date
și Algoritmi

Tema: Implementarea tipului de date abstract “Arbore binar” în limbajul C.

A efectuat: Cioresco Adrian

A verificat: Bîrnaz Adrian

Chisinău 2023
Scopul lucrării Scopul lucrării este de a familiariza studentul cu mecanismul de creare a arborelui
binar de căutare și operații elementare asupra acestuia, utilizînd pentru aceasta limbajul C.

#include <stdlib.h>

#include <stdio.h>

#include <conio.h>

#define COUNT 10

int n, ln=0;

typedef struct City

int nr;

char * name;

int population;

char * location;

} City;

typedef struct BinaryTreeNode

City * data;

struct BinaryTreeNode * left;

struct BinaryTreeNode * right;

} BinaryTreeNode;

BinaryTreeNode * newBinaryTreeNode(City * data)

BinaryTreeNode * new_node = calloc(sizeof(BinaryTreeNode),1);

new_node->data = data;
 return new_node;

typedef struct BinaryTree

struct BinaryTreeNode * root;

} BinaryTree;

struct BinaryTree * create_tree()

BinaryTree *my_binary = malloc(sizeof(struct BinaryTree));

my_binary->root = NULL;

return my_binary;

City * create_city(int nr, char * name, int population, char * location)

City * city = malloc(sizeof(City));

city->nr = nr;

city->name = strdup(name);

city->population = population;

city->location = strdup(location);

return city;

void read_BinaryTree(BinaryTree * BinaryTree, int n)

int nr, population;

char name[20], location[20];

 for(int i=0; i<n; i++)

printf("ORASUL NR. %d\n", i+1);

printf("Introduceti numarul orasului: ");

scanf("%d", &nr);

printf("Introduceti numele orasului: ");

scanf("%s", name);

printf("Introduceti nr populatiei: ");

scanf("%d", &population);

printf("Introduceti locatia orasului: ");

scanf("%s", location);

printf("\n");

City * city = create_city(nr,name,population, location);

insertNewNodeInTree(BinaryTree, city);

void print_city(BinaryTreeNode * current_node)

if(current_node)

printf("\n\nInformatie oras \n");

printf(" Numarul: %d \n", current_node->data->nr);

printf(" Numele orasului: %s \n", current_node->data->name);

printf(" Populatia: %d \n", current_node->data->population);

printf(" Locatia: %s \n", current_node->data->location);

print_city(current_node->left);

print_city(current_node->right);

}
void insertNewNode(BinaryTreeNode * current_node, BinaryTreeNode * new_node)

if(current_node)

if(current_node->data->nr > new_node->data->nr)

if(current_node->left)

insertNewNode(current_node->left,new_node);

else

current_node->left = new_node;

else

if(current_node->right)

insertNewNode(current_node->right,new_node);

else

current_node->right = new_node;

}
void insertNewNodeInTree(BinaryTree * myBinaryTree, City * city)

BinaryTreeNode * new_node = newBinaryTreeNode(city);

if(myBinaryTree->root)

insertNewNode(myBinaryTree->root, new_node);

++n;//se mareste numarul total de noduri

else

myBinaryTree->root = new_node;

++n;//

void SVD(BinaryTreeNode * current_node)

if (current_node == NULL)

return;

else

SVD(current_node->left);

printf("%d -> ", current_node->data->nr);

SVD(current_node->right);

}
void VSD(BinaryTreeNode * current_node)

if (current_node == NULL)

return;

printf("%d -> ", current_node->data->nr);

VSD(current_node->left);

VSD(current_node->right);

void SDV(BinaryTreeNode * current_node)

if (current_node == NULL)

return;

SDV(current_node->left);

SDV(current_node->right);

printf("%d -> ", current_node->data->nr);

void printCurrentLevel(BinaryTreeNode * current_node, int level);

int height(BinaryTreeNode* node);

void printLevelOrder(BinaryTreeNode * current_node)

int h = height(current_node);
 int i;

for (i = 1; i <= h; i++)

printCurrentLevel(current_node, i);

void printCurrentLevel(BinaryTreeNode * current_node, int level)

if (current_node == NULL)

return;

if (level == 1)

printf("%d ", current_node->data->nr);

else if (level > 1) {

printCurrentLevel(current_node->left, level - 1);

printCurrentLevel(current_node->right, level - 1);

int height(BinaryTreeNode * current_node)

if (current_node == NULL)

return 0;

else

int lheight = height(current_node->left);

int rheight = height(current_node->right);

if (lheight > rheight)

return (lheight + 1);

 }

else

return (rheight + 1);

int TreeHeight(BinaryTreeNode * current_node)

system("cls");

if(current_node == NULL)

return -1;

else

int Lmax = TreeHeight(current_node->left);

int Rmax = TreeHeight(current_node->right);

if(Lmax>Rmax)

return (Lmax+1);

else

return (Rmax+1);

}
void Mirror_BinaryTree(BinaryTreeNode * current_node)

if (current_node==NULL)

return;

else

BinaryTreeNode * temp;

Mirror_BinaryTree(current_node->left);

Mirror_BinaryTree(current_node->right);

temp = current_node->left;

current_node->left = current_node->right;

current_node->right = temp;

void DeleteTreeNode(BinaryTreeNode * current_node)

if(current_node)

DeleteTreeNode(current_node->left);

DeleteTreeNode(current_node->right);

free(current_node);

}
void ClearTree(BinaryTree * Tree)

if(Tree)

if(Tree->root)

DeleteTreeNode(Tree->root);

Tree->root = NULL;

void DeleteTree(BinaryTree *Tree)

if(Tree)

ClearTree(Tree);

free(Tree);

printf("Stergerea arborelui binar a avut loc cu succes\n");

BinaryTreeNode *SearchInTree(BinaryTreeNode * current_node, int cheie)

system("cls");

if (current_node == NULL)

return NULL;
 }

if(cheie == current_node->data->nr)

printf("Nodul a fost gasit in %d pasi.", ln);

ln=0;

printf("\nINFORMATIA ORASULUI GASIT\n");

printf("Numarul orasului: %d\n", current_node->data->nr);

printf("Numele orasului: %s\n", current_node->data->name);

printf("Populatia: %d\n", current_node->data->population);

printf("Locatia orasului: %s\n", current_node->data->location);

return;

if(current_node && cheie<current_node->data->nr)

++ln;

SearchInTree(current_node->left,cheie);

else

++ln;

SearchInTree(current_node->right,cheie);

// functie pentru a realiza rotatia la dreapta

struct BinaryTreeNode * rotateRight(struct BinaryTreeNode* node) {

struct BinaryTreeNode * x = node->left;

struct BinaryTreeNode * y = x->right;

// rotatia
 x->right = node;

node->left = y;

return x;

// functie pentru a realiza rotatia la stanga

struct BinaryTreeNode* rotateLeft(struct BinaryTreeNode* node) {

struct BinaryTreeNode* x = node->right;//fiul drept a nodului

struct BinaryTreeNode* y = x->left;//fiul stang a lui x

// rotatia

x->left = node;//x-> nod

node->right = y;//node->fiul stang a lui x

//fiul stang->fiul drept a nodului curent

return x;

// functie pentru a echilibra arborele

struct BinaryTreeNode* balanceTree(struct BinaryTreeNode* node) {

int balance = 0;

if (node == NULL) {

return NULL;

// calculam factorul de balans

 balance = height(node->left) - height(node->right);

// daca arborele este neechilibrat, aplicam rotatia corespunzatoare

if (balance > 1) {

if (height(node->left->left) >= height(node->left->right)) {

node = rotateRight(node);

else {

node->left = rotateLeft(node->left);

node = rotateRight(node);

//daca este -1 subarborele drept este mai inalt si trebuie echilibrat

else if (balance < -1) {

if (height(node->right->right) >= height(node->right->left)) {

node = rotateLeft(node);

else {

node->right = rotateRight(node->right);

node = rotateLeft(node);

return node;

int menu()

system("cls");

printf("\n******************Menu**********************");

printf("\n 1)Citeste elementele arborelui");

 printf("\n 2)Afiseaza elementele arborelui binar");

printf("\n 3)Cauta un nod in baza campului cheie si afiseaza campurile

nodului gasit");

printf("\n 4)Parcurge arborele in inordine(SVD)");

printf("\n 5)Parcurge arborele in preordine(VSD)");

printf("\n 6)Parcurge arborele in postordine(SDV)");

printf("\n 7)Parcurge arborele in adancime (DFS)");

printf("\n 8)Parcurge arborele in largime (BFS)");

printf("\n 9)Balanseaza arborele");

printf("\n 10)Oglindeste arborele");

printf("\n 11)Curata elementele arborelui");

printf("\n 12)Elibereaza memoria arborelui");

printf("\n 0)Opreste programul");

printf("\n\nAlege nr. din meniu: ");

int var1 = 12;

scanf("%d", &var1);

return var1;

int main()

int cheie, var1 = 12;

BinaryTree *BinaryTree = NULL;

while(var1)

var1=menu();

switch(var1)

{
case 1:

BinaryTree = create_tree();

printf("Introduce-ti numarul de noduri: ");

scanf("%d", &n);

read_BinaryTree(BinaryTree,n);

break;

case 2:

print_city(BinaryTree->root);

break;

case 3:

int cheie;

printf("\nIntroduceti cheia: ");

scanf("%d", &cheie);

SearchInTree(BinaryTree->root,cheie);

//search(BinaryTree->root,cheie);

break;

case 4:

SVD(BinaryTree->root);

break;

case 5:

VSD(BinaryTree->root);

break;
}

case 6:

SDV(BinaryTree->root);

break;

case 7:

printf("1 tip de DFS:\n");

SVD(BinaryTree->root);

printf("2 tip de DFS:\n");

VSD(BinaryTree->root);

printf("3 tip de DFS:\n");

SDV(BinaryTree->root);

break;

case 8:

printLevelOrder(BinaryTree->root);

break;

case 9:

balanceTree(BinaryTree->root);

break;

case 10:

Mirror_BinaryTree(BinaryTree->root);

break;

}
 case 11:

ClearTree(BinaryTree);

break;

case 12:

DeleteTree(BinaryTree);

BinaryTree = NULL;

break;

case 0:

return 0;

default:

printf("Introduceti un numar de la 0-12!");

printf("\n\nApasa orice tasta+enter pentru a continua.\n");

getch();

return 0;