Ministerul Educaţiei, Culturii și Cercetării al Republicii Moldova

Universitatea Tehnică a Moldovei

Departamentul Informatică și Ingineria Sistemelor

RAPORT
Lucrarea de laborator nr. 5
La Structuri de Date și Algoritmi

A efectuat:
st. gr. CR-211 Bivol Vasile

A verificat:
dr., conf. univ. Mihail Kulev

Chişinău -2022
 Lucrare de Laborator nr 5
Tema:
Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi
Scopul lucrării:
Obţinerea deprinderilor practice de implementare și de utilizare a tipului abstract de date (TAD)
„Arbore binar” cu asigurarea operațiilor de prelucrare de bază ale arborelui binar oarecare prin
parcurgerea nodurilor arborelui “în lăţime” şi “în adâncime”, folosind structurile respective de
date “coadă” şi “stivă”.
Condiţia problemei (sarcina de lucru):
Să se scrie trei fişiere-text în limbajul C pentru implementarea și utilizarea TAD „Arbore binar”
cu asigurarea operațiilor de prelucrare de bază ale arborelui binar oarecare prin parcurgerea
nodurilor arborelui cu ajutorul algoritmilor iterativi:
1. Fişier antet cu extensia .h, care conține specificarea structurii de date a nodului arborelui
binar (conform variantelor) şi a structurilor de date ale elementelor cozii și stivei, precum și
prototipurile funcţiilor de prelucrare ale arborelui binar oarecare, bazate pe algoritmi iterativi.
2. Fişier cu extensia .cpp sau .c, care conține implementările funcţiilor (codurile funcţiilor),
declarate în fişierul antet.
3. Fişier al utilizatorului, funcţia mаin() pentru prelucrarea arborelui binar oarecare cu afişarea
la ecran a următorului meniu de opţiuni:
1. Crearea nodurilor arborelui binar oarecare în memoria dinamică și introducerea informaţiei
despre nodurile arborelui de la tastatură în mod interactive.
2. Afişarea informaţiei despre nodurile arborelui la ecran.
3. Căutarea nodului în arbore.
4. Modificarea informației unui nod din arbore.
5. Determinarea numărului de noduri.
6. Determinarea înălţimii arborelui.
7. Eliberarea memoriei alocate pentru arbore.
0. Ieşirea din program.

Varianta :
3. Structura Hotel cu câmpurile: denumirea, adresa, telefonul, categoria, numărul de
locuri.

Mersul lucrării:

Noţiuni din teorie şi metode folosite conform temei lucrării:

1. La realizarea operaţiei de afişare la ecran a informaţiei referitor la nodurile arborelui a
se prevedea și afişarea adreselor din memorie ale nodului curent precum și fiilor stâng şi drept ai
nodului curent.
2. Funcțiile de prelucrare ale arborelui binar oarecare trebuie implementate folosind algoritmi
iterativi în 2 versiuni:
a) utilizînd coada - pentru parcurgerea arborelui “în lățime” (parcurgerea arborelui pe niveluri);
b) utilizând stiva – pentru parcurgerea arborelui “în adîncime” (parcurgerea “în inordine”:
rădăcină -> subarbore stâng(drept) -> subarbore drept(stâng). O excepție face funcția de eliberare
a memoriei dinamice alocate pentru arbore (trebuie folosită parcurgerea “în postordine”:
subarbore stâng(drept) -> subarbore drept(stâng) -> rădăcină).

Descrierea variabilelor:
1)Fișiere:
Hotele-header.h – fișier de tip header
Hotele-functii.c – fișier de tip C
Hotele-main.c – fișier de tip C

2)Date de intrare:
nume[40], strada[40], telefon[40], , spec[40] – variabile de tip char. (De introdus de
la tastatură de către utilizator).
locuri, numarul de ordine – variabile de tip integer. . (De introdus de la tastatură de către
utilizator).

3) date de ieşire:
nume[40], strada[40], telefon[40], spec[40] – variabile de tip char.
locuri, numarul de ordine – variabilă de tip integer.

4) date de lucru:
n, c, v, e1, e2 – variabilă de tip integer.

Codul (textul, listing-ul) programului în limbajul C:

Lab11 Head.h
typedef struct Hotel
{
char denumire[50];
char adresa[50];
char telefonul[50];
char categoria[50];
int locuri;
char specializare[50];
struct Hotel* left;
struct Hotel* right;
}Hotel;

Hotel* root;

Hotel *create_recursiv();
void show_recursiv_RSD(Hotel *c);
void show_recursiv_SRD(Hotel *c);
void show_recursiv_SDR(Hotel *c);
void show_recursiv_DRS(Hotel *c);
void show_recursiv_DSR(Hotel *c);

Hotel *search_recursiv(Hotel *c, char *name);

int modify(Hotel *v);

int Hoteles_count_recursiv(Hotel *c);

int height_recursiv(Hotel *c);

void free_recursiv(Hotel *c);

Lab11 Functii.c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"11_head.h"

Hotel *create_recursiv()
{
int f;
Hotel *c;

c = (Hotel*)malloc(sizeof(Hotel));

if(!c)
{
return NULL;
}

puts("\n Dati informatia despre Hotel: \n");

printf(" Denumirea: ");
fflush(stdin);
gets(c->denumire);
printf(" Adresa: ");
fflush(stdin);
gets(c->adresa);
printf(" Telefonul: ");
fflush(stdin);
gets(c->telefonul);
printf(" Categoria: ");
fflush(stdin);
gets(c->categoria);
printf(" Nr.de locuri: ");
scanf("%d",&c->locuri);
 printf(" Specializare: ");
fflush(stdin);
gets(c->specializare);
printf("\n");

printf(" Doriti sa creati copilul S_tang al Hotelului %s ? (1-DA / 0-NU): ", c->denumire);
scanf("%d",&f);
if(f == 1)
{
c->left = create_recursiv();
}
else
{
c->left = NULL;
}

printf(" Doriti sa creati copilul D_rept al Hotelului %s ? (1-DA / 0-NU): ", c-

>denumire);
scanf("%d",&f);
if(f == 1)
{
c->right = create_recursiv();
}
else
{
c->right = NULL;
}

return c;
}
//preordine
void show_recursiv_RSD(Hotel *c)
{
if(c)
{
printf("Denumirea: %s\n",c->denumire);
printf("Adresa: %s\n", c->adresa);
printf("Telefonul: %s\n", c->telefonul);
printf("Categoria: %s\n", c->categoria);
printf("Nr.locuri: %d\n", c->locuri);
printf("Specializare: %s\n", c->specializare);
printf("Adresa elementului curent: %p\n", c);
printf("Adresa copilului stang: %p\n", c->left);
printf("Adresa copilului drept: %p\n", c->right);
printf("\n\n");

show_recursiv_RSD(c->left);
show_recursiv_RSD(c->right);
}

return;
}
 //inordine
void show_recursiv_SRD(Hotel *c)
{
if(c)
{
show_recursiv_SRD(c->left);

printf("Denumirea: %s\n",c->denumire);
printf("Adresa: %s\n", c->adresa);
printf("Telefonul: %s\n", c->telefonul);
printf("Categoria: %s\n", c->categoria);
printf("Nr.locuri: %d\n", c->locuri);
printf("Specializare: %s\n", c->specializare);
printf("Adresa elementului curent: %p\n", c);
printf("Adresa copilului stang: %p\n", c->left);
printf("Adresa copilului drept: %p\n", c->right);
printf("\n\n");

show_recursiv_SRD(c->right);
}

return;
}
//postordine
void show_recursiv_SDR(Hotel *c)
{
if(c)
{
show_recursiv_SDR(c->left);
show_recursiv_SDR(c->right);

printf("Denumirea: %s\n",c->denumire);
printf("Adresa: %s\n", c->adresa);
printf("Telefonul: %s\n", c->telefonul);
printf("Categoria: %s\n", c->categoria);
printf("Nr.locuri: %d\n", c->locuri);
printf("Specializare: %s\n", c->specializare);
printf("Adresa elementului curent: %p\n", c);
printf("Adresa copilului stang: %p\n", c->left);
printf("Adresa copilului drept: %p\n", c->right);
printf("\n\n");
}

return;
}

void show_recursiv_DRS(Hotel *c)

{
if(c)
{
show_recursiv_DRS(c->right);
 printf("Denumirea: %s\n",c->denumire);
printf("Adresa: %s\n", c->adresa);
printf("Telefonul: %s\n", c->telefonul);
printf("Categoria: %s\n", c->categoria);
printf("Nr.locuri: %d\n", c->locuri);
printf("Specializare: %s\n", c->specializare);
printf("Adresa elementului curent: %p\n", c);
printf("Adresa copilului stang: %p\n", c->left);
printf("Adresa copilului drept: %p\n", c->right);
printf("\n\n");

show_recursiv_DRS(c->left);
}

return;
}

void show_recursiv_DSR(Hotel *c)

{
if(c)
{
show_recursiv_DSR(c->right);
show_recursiv_DSR(c->left);

printf("Denumirea: %s\n",c->denumire);
printf("Adresa: %s\n", c->adresa);
printf("Telefonul: %s\n", c->telefonul);
printf("Categoria: %s\n", c->categoria);
printf("Nr.locuri: %d\n", c->locuri);
printf("Specializare: %s\n", c->specializare);
printf("Adresa elementului curent: %p\n", c);
printf("Adresa copilului stang: %p\n", c->left);
printf("Adresa copilului drept: %p\n", c->right);
printf("\n\n");
}

return;
}

Hotel *search_recursiv(Hotel *c, char *name)

{
Hotel *p = NULL;

if(!c)
{
return NULL;
}
if(strcmp(c->denumire,name) == 0)
{
return c;
 }

p = search_recursiv(c->left, name);
if(p)
{
return p;
}

p = search_recursiv(c->right, name);
if(p)
{
return p;
}
return NULL;
}

int modify(Hotel *v)

{
if(v == NULL)
{
puts("Hotelul nu exista");
return 0;
}
else
{
printf(" Denumirea: ");
fflush(stdin);
gets(v->denumire);
printf(" Adresa: ");
fflush(stdin);
gets(v->adresa);
printf(" Telefonul: ");
fflush(stdin);
gets(v->telefonul);
printf(" Categoria: ");
fflush(stdin);
gets(v->categoria);
printf(" Nr.de locuri: ");
scanf("%d",&v->locuri);
printf(" Specializare: ");
fflush(stdin);
gets(v->specializare);
printf("\n");
return 1;
}
}

int Hoteles_count_recursiv(Hotel *c)

{
int k;

if(!c)
 {
return 0;
}

k = Hoteles_count_recursiv(c->left) + 1 + Hoteles_count_recursiv(c->right);
return k;
}

int height_recursiv(Hotel *c)

{
int l,r;
if(!c)
{
return -1;
}

l = height_recursiv(c->left);
r = height_recursiv(c->right);

if(l > r)
{
return(l + 1);
}
else
{
return(r + 1);
}
}

void free_recursiv(Hotel *c)

{
if(c)
{
free_recursiv(c->left);
free_recursiv(c->right);
free(c);
}
return;
}
Lab11 main.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"11_functions.c"

int main()
{
int nm, x, f, k, h;
Hotel *c;
char name[50];
 puts("\n\t Menu:");
puts("1. Crearea Hotelurilor arborelui binar");
puts("2. Afisarea informatiei despre Hotelurile arborelui la ecran");
puts("3. Cautarea Hotelului in arbore");
puts("4. Modificarea informatiei unui Hotel din arbore");
puts("5. Determinarea numarului de Hoteluri");
puts("6. Determinarea inaltimii arborelui");
puts("7. Eliberarea memoriei alocate pentru arbore ");
puts("0. Iesire din program");

while(1)
{
printf("\n\t Optiunea:");
scanf("%d", &nm);

switch(nm)
{
case 1:
{
root = NULL;
printf("Introdu informatia despre radacina: \n\n");
root = create_recursiv();
break;
}
case 2:
{
printf("Alege optiunea de afisare:\n\n");

printf("1.Preordine(RSD) \n");
printf("2.Inordine(SRD) \n");
printf("3.Postordine(SDR) \n");
printf("4.(DRS) \n");
printf("5.(DSR) \n");

x=1;

while(x>0)
{

printf("\n\t Optiunea de afisare:");

scanf("%d", &x);

if(x==1)
{
show_recursiv_RSD(root);

}
else if(x==2)
{
show_recursiv_SRD(root);

}
 else if(x==3)
{
show_recursiv_SDR(root);

}
else if(x==4)
{
show_recursiv_DRS(root);

}
else if(x==5)
{
show_recursiv_DSR(root);

}
else {
break;
}

}
break;
}
case 3:
{
printf("Introdu denumirea Hotelului: ");
fflush(stdin);
gets(name);
c = search_recursiv(root,name);
if(c)
{
printf("Denumirea: %s\n",c->denumire);
printf("Adresa: %s\n", c->adresa);
printf("Telefonul: %s\n", c->telefonul);

printf("Nr.de locuri: %d\n", c->locuri);

printf("Adresa elementului curent: %x\n", c);
printf("Adresa copilului stang: %x\n", c->left);
printf("Adresa copilului drept: %x\n", c->right);
printf("\n\n");
}
else
{
puts("Hotelul nu a fost gasit");
}
break;
}
case 4:
{
printf("Introdu denumirea Hotelului pentru
modificare: ");
fflush(stdin);
 gets(name);
c = search_recursiv(root,name);
if(c)
{
printf("Denumirea: %s\n",c->denumire);
printf("Adresa: %s\n", c->adresa);
printf("Telefonul: %s\n", c->telefonul);

printf("Nr.locuri: %d\n", c->locuri);

printf("Categoria: %s\n", c-
>categoria);
printf("Specializare: %s\n", c->specializare);
printf("Adresa elementului curent: %x\n", c);
printf("Adresa copilului stang: %x\n", c->left);
printf("Adresa copilului drept: %x\n", c->right);
printf("\n\n");

f = modify(c);
if(f)
{
puts("Hotelul a fost modificat ");
}
else
{
puts("Hotelul nu a fost
modificat");
}
}
else
{
puts("Hotelul nu a fost gasit");
}

break;
}
case 5:
{
k = Hoteles_count_recursiv(root);
if(k == 0)
{
puts("Eroare in determinarea
numarului de Hoteluri");
}
else
{
printf("Numarul de Hoteluri in
arbore : %d",k);
}
break;
}
case 6:
{
 if(root)
{
h = height_recursiv(root);
printf("Inaltimea arborelui: %d",h);
}
else
{
printf("Radacina nu exista");
}
break;
}
case 7:
{
free_recursiv(root);

puts("Memoria a fost eliberata");

root = NULL;

break;
}
case 0:
{
exit(1);
}
default :
{
puts("Optiune gresita !");
break;
}
}
}

return 0;
}
Rezultatele testării și funcţionării programului:
 Analiza rezultatelor și concluzii:

1. Programul dat a avut o strcutură asemănătoare cu cel din lucrarea de laborator trecută,
ceea ce a permis iar împărțirea codului în trei părți și economisirea locului.
2. Mulțumită implementării header-ului și a funcțiilor în main a fost posibilă folosirea unui
document cu mult mai scurt, comparative cu cel din laboratorul numărul 6.

Bibliografie:
1. https://else.fcim.utm.md/mod/assign/view.php?id=32769
2. https://else.fcim.utm.md/course/view.php?id=379
3. https://www.coursehero.com/file/p4l8ln5q/%C8%99i-de-utilizare-a-tipului-abstract-
de-date-TAD-Arbore-binar-cu-asigurarea/
4. http://repository.utm.md/bitstream/handle/5014/15229/
ProgramareaCalculatoarelor_StructuriDateAlgoritmi_C_DS.pdf?sequence=1
5. http://www.cs.ubbcluj.ro/~gabis/fp/Documentatii/TAD.pdf
6. https://else.fcim.utm.md/mod/assign/view.php?id=32768