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

Universitatea Tehnică a Moldovei

Departamentul Informatică și Ingineria Sistemelor

RAPORT
Lucrarea de laborator nr.10.
la Programarea Calculatoarelor

A efectuat:
st. gr. RM-211 Dascal Sergiu
A verificat:
dr., conf. univ. M. Kulev

Chişinău -2021
 Lucrarea de laborator nr. 10
Теmа: 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ă”.
Sarcină: 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.
Indicaţii:
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ă).
Valorile datelor iniţiale : n=2,
struct casa
char adresa[50];
int telefon;
float suprafata;
int numar_odai;
float cost;
 Mersul lucrării:
Noţiuni din teorie şi metodele folosite:
În Programarea calculatoarelor algoritmul este un set finit de operatiuni
(actiuni) pentru a rezolva problema dată la calculator. Există mai multe
forme de reprezentare a algoritmilor [2]:
- forma naturală;
- forma grafică;
- pseudocodul;
- programul scris intr-un limbaj de programare.

Algoritm cu structură ramificata este caracterizat prin prezenta

operaţiunilor de decizie [2].
Algoritm cu structură ciclica este caracterizat prin prezenta operatiunilor
recursive [2].

Structura generală a unui program in limbajul C este urmatoarea [2 - 4]:

- directivele preprocesorului (după necisitate);
- declarațiile variabelelor globale și a funcțiilor programului (după
necesitate);
- cudul functiei principale main( );
- codurile altor funcții programului (după necesitate).
Structura funcției în limbajul C [2 - 4] :
1. Antetul funcției, sau prima linie a codului funcției, care constă din 3
elemente: a) tipul funcției; b) denumirea funcției; c) lista tipurilor și
denumirelor a parametrilor funcției scrisă între parantezele rotunde.
2. Corpul funcției scris între acolade { }.
a) date de intrare:
n, struct casa- variabila simple de tip integer si tabloul structura
(de introdus de la tastatură).
b) date de ieşire:
struct casa- variabile simple de tip real, valorile formulelor de calcul
(de afişat pe ecran).
c) date de lucru:
casa *p, casa *c, casa *t, casa *x, casa *root, casa *left, casa *right,
casa *adrnod, elq *next, elq *first, elq *last, elq *c, elq *p, els *next1,
els *top, els *c, els *p, fname[100] str[100], flag, i, f, r, l, o,
Codul programului in limbajul C:
#include <stdio.h>
typedef struct casa
{
char adresa[50];
int telefon;
float suprafata;
int numar_odai;
float cost;
struct casa *left;
struct casa *right;
}casa;
casa *root=NULL;

// coada
typedef struct elq{
casa *adrnod;
struct elq *next;
}elq;
elq *first=NULL;
elq *last=NULL;
// stiva
typedef struct els{
 casa *adrnod;
struct els *next1;
}els;
els *top=NULL;//head

//Quad
int inq(casa *inf);
casa* delq();
int creat_q();
int show_q();
casa* search_q(char *fname);
void modify(casa *c);
int size_q();
int height_q(casa *c);
int freemem_q();

//Stack
int push(casa *inf);
casa* pop();
int creat_s();
int show_s();
casa* search_s(char *fname);
int size_s();
int height_s(casa *c);
int freemem_s();
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include "LAB 10.h"

//Functiile pentru quad

int inq(casa *x)
{
elq *c;
c=(elq*)malloc(sizeof(elq));
if(!c)
return 0;
if(!first)
{
first = c;
}
else
{
last->next=c;
}
 last=c;
c->next=NULL;
c->adrnod=x;
return 1;
}

casa* delq()
{
elq *c=first;
casa *x;
if(c == last)
{
first=last=NULL;
}
else
{
first=c->next;
}
x=c->adrnod;
free(c);
return x;
}
int creat_q()
{
int f;
casa *c,*p;
first=last=NULL;
printf(" Doriti sa creati radacina arborelui (1/0)?: ");
scanf("%d",&f);
if(f)
{
c=(casa*)malloc(sizeof(casa));
if(!c)
return -1;
printf(" Introduceti datele radacinei:\n");
printf("Adresa : ");
fflush(stdin);
gets(c->adresa);
printf("Telefonul : ");
scanf("%d", &c->telefon);
printf("Suprafata : ");
scanf("%f", &c->suprafata);
printf("Numarul de odai : ");
scanf("%d", &c->numar_odai);
printf("Costul : ");
 scanf("%f", &c->cost);
if(!inq(c))
return -2;
root = c;
}
else
{
root = NULL;
}
while(first)
{
p = delq();
printf(" Doriti sa creati copilul sting al nodului %s (1/0)?:
",p->adresa);
scanf("%d",&f);
if(f)
{
c=(casa*)malloc(sizeof(casa));
if(!c)
return -3;
printf(" Introduceti datele copilului sting\n");
printf("Adresa : ");
fflush(stdin);
gets(c->adresa);
 printf("Telefonul : ");
scanf("%d", &c->telefon);
printf("Suprafata : ");
scanf("%f", &c->suprafata);
printf("Numarul de odai : ");
scanf("%d", &c->numar_odai);
printf("Costul : ");
scanf("%f", &c->cost);
p->left=c;
if(!inq(c))
return -2;
}
else
{
p->left=NULL;
}
printf(" Doriti sa creati copilul drept al nodului %s (1/0)?: ",p-
>adresa);
scanf("%d",&f);
if(f)
{
c=(casa*)malloc(sizeof(casa));
if(!c)
return -3;
 printf(" Introduceti datele copilului drept\n");
printf("Adresa : ");
fflush(stdin);
gets(c->adresa);
printf("Telefonul : ");
scanf("%d", &c->telefon);
printf("Suprafata : ");
scanf("%f", &c->suprafata);
printf("Numarul de odai : ");
scanf("%d", &c->numar_odai);
printf("Costul : ");
scanf("%f", &c->cost);
p->right = c;
if(!inq(c))
return -2;
}
else
{
p->right = NULL;
}
}
return 1;
}
int show_q()
{
casa *p,*c;
first=last=NULL;
if(!root)
return 0;
p=root;
if(!inq(p))
return -2;
printf(" Lista nodurilor\n\n");
while(first)
{
p=delq();
printf("\n\tCasa numarul : %s\n",p->adresa);
printf("Adresa : %s\n", p->adresa);
printf("Telefonul : %d\n", p->telefon);
printf("Suprafata : %.2f\n", p->suprafata);
printf("Numarul de odai : %d\n", p->numar_odai);
printf("Costul : %.2f\n", p->cost);
c=p->left;
if(c)
{
 if(!inq(c))
return -2;
}
c=p->right;
if(c)
{
if(!inq(c))
return -2;
}
}
return 1;
}
/*
int show_q(){
nod *p,*c;
first=last=NULL;
if(!root) return 0;
p=root;
if(!inq(p)) return -2;
printf(" Lista nodurilor\n\n");
while(first){
p=delq();
printf(" ---Nodul %s---\n",p->nume);
 printf(" Nume: %s\n",p->nume);
printf(" Capitala: %s\n",p->capitala);
printf(" Presedinte: %s\n",p->presedinte);
printf(" Populatia: %d\n",p->populatia);
printf(" Suprafata: %d\n\n",p->suprafata);
c=p->left;
if(c){
if(!inq(c)) return -2;
}
c=p->right;
if(c){
if(!inq(c)) return -2;
}
}
return 1;
}*/

casa* search_q(char *fname)

{
casa *p,*c;
first=last=NULL;
if(!root) return NULL;
p=root;
 if(!inq(p)) return NULL;
while(first)
{
p=delq();
if(!strcmp(p->adresa,fname))
return p;
c=p->left;
if(c)
{
if(!inq(c)) return NULL;
}
c=p->right;
if(c)
{
if(!inq(c)) return NULL;
}
}
return NULL;
}

void modify(casa *c)

{
int flag;
printf("Doriti sa modificati adresa? (1/0) : ");
scanf("%d", &flag);
if(flag)
{
printf("Adresa curenta : %s\n", c->adresa);
printf("Adresa noua : ");
fflush(stdin);
gets(c->adresa);
}
printf("Doriti sa modificati telefonul? (1/0) : ");
scanf("%d", &flag);
if(flag)
{
printf("Telefonul curent : %d\n", c->telefon);
printf("Telefonul nou : ");
scanf("%d", &c->telefon);
}
printf("Doriti sa modificati suprafata? (1/0) : ");
scanf("%d", &flag);
if(flag)
{
printf("Suprafata curenta : %.2f\n", c->suprafata);
printf("Suprafata noua : ");
 scanf("%f", &c->suprafata);
}
printf("Doriti sa modificati numarul de odai? (1/0) : ");
scanf("%d", &flag);
if(flag)
{
printf("Numarul curent de odai : %d\n", c->numar_odai);
printf("Numarul nou de odai : ");
scanf("%d", &c->numar_odai);
}
printf("Doriti sa modificati costul? (1/0) : ");
scanf("%d", &flag);
if(flag)
{
printf("Costul curent : %.2f\n", c->cost);
printf("Costul nou : ");
scanf("%f", &c->cost);
}
printf("Modificarea a avut loc cu succes!");
return;
}

int size_q()
{
int s=0;
casa *p,*c;
first=last=NULL;
if(!root)
return 0;
p=root;
if(!inq(p))
return -2;
while(first)
{
p=delq();
s++;
c=p->left;
if(c)
{
if(!inq(c))
return -2;
}
c=p->right;
if(c)
{
if(!inq(c))
 return -2;
}
}
return s;
}

int height_q(casa *c)

{
int l=0,r=0;
if(!c)
return -1;
l=1+height_q(c->left);
r=1+height_q(c->right);
if(l>r) return l;
else
return r;
}

int freemem_q()
{
casa *p,*c;
first=last=NULL;
if(!root)
 return 0;
p=root;
if(!inq(p))
return -2;
while(first)
{
p=delq();
c=p->left;
if(c)
{
if(!inq(c))
return -2;
}
c=p->right;
if(c)
{
if(!inq(c))
return -2;
}
free(p);
}
return 1;
}
//Functiile pentru Stack
int push(casa *x)
{
els *c;
c=(els*)malloc(sizeof(els));
if(!c) return 0;
c->next1=top;
c->adrnod=x;
top=c;
return 1;
}

casa* pop()
{
els *c=top;
casa *x;
top=c->next1;
x=c->adrnod;
free(c);
return x;
}
int creat_s()
{
casa *p, *c;
int f;
root=NULL;
top=NULL;
printf(" Doriti sa creati radacina arborelui (1/0)? : ");
fflush(stdin);
scanf("%d",&f);
if(f)
{
c=(casa*)malloc(sizeof(casa));
if(!c)
return -1;
printf(" Introduceti datele \n");
printf("Adresa : ");
fflush(stdin);
gets(c->adresa);
printf("Telefonul : ");
scanf("%d", &c->telefon);
printf("Suprafata : ");
scanf("%f", &c->suprafata);
printf("Numarul de odai : ");
 scanf("%d", &c->numar_odai);
printf("Costul : ");
scanf("%f", &c->cost);
if(!push(c))
return -5;
root=c;
while(top)
{
p=pop();
printf(" Doriti sa creati copilul drept al nodului %s (1/0)?:
",p->adresa);
fflush(stdin);
scanf("%d",&f);
if(f)
{
c=(casa*)malloc(sizeof(casa));
if(!c)
return -3;
printf(" Introduceti datele\n");
printf("Adresa : ");
fflush(stdin);
gets(c->adresa);
printf("Telefonul : ");
scanf("%d", &c->telefon);
 printf("Suprafata : ");
scanf("%f", &c->suprafata);
printf("Numarul de odai : ");
scanf("%d", &c->numar_odai);
printf("Costul : ");
scanf("%f", &c->cost);
p->right = c;
if(!push(c))
return -5;
}
else
{
p->right = NULL;
}
printf(" Doriti sa creati copilul sting al nodului %s
(1/0)?: ",p->adresa);
fflush(stdin);
scanf("%d",&f);
if(f)
{
c=(casa*)malloc(sizeof(casa));
if(!c)
return -3;
printf(" Introduceti datele\n");
 printf("Adresa : ");
fflush(stdin);
gets(c->adresa);
printf("Telefonul : ");
scanf("%d", &c->telefon);
printf("Suprafata : ");
scanf("%f", &c->suprafata);
printf("Numarul de odai : ");
scanf("%d", &c->numar_odai);
printf("Costul : ");
scanf("%f", &c->cost);
p->left=c;
if(!push(c))
return -5;
}
else
{
p->left=NULL;
}
}
}
return 1;
}
int show_s()
{
casa *p,*c;
top=NULL;
if(!root) return 0;
p=root;
if(!push(p)) return -5;
printf("Lista nodurilor\n\n");
while(top)
{
p=pop();
printf("\n\tCasa numarul : %s\n",p->adresa);
printf("Adresa : %s\n", p->adresa);
printf("Telefonul : %d\n", p->telefon);
printf("Suprafata : %.2f\n", p->suprafata);
printf("Numarul de odai : %d\n", p->numar_odai);
printf("Costul : %.2f\n", p->cost);
c=p->right;
if(c!=NULL)
{
if(!push(c))
return -5;
 }
c=p->left;
if(c!=NULL)
{
if(!push(c))
return -5;
}
}
printf("\n");
return 1;
}

casa* search_s(char *fname)

{
strlwr(fname);
casa *p,*c;
top=NULL;
if(!root) return NULL;
p=root;
if(!push(p))
return NULL;
while(top)
{
 p=pop();
strlwr(c->adresa);
if(!strcmp(fname,p->adresa)) return p;
c=p->right;
if(c!=NULL)
{
if(!push(c))
return NULL;
}
c=p->left;
if(c!=NULL)
{
if(!push(c))
return NULL;
}
}
return NULL;
}

int size_s()
{
casa *p,*c;
int s=0;
 top=NULL;
if(!root) return 0;
p=root;
if(!push(p))
return -5;
while(top)
{
p=pop();
s++;
c=p->right;
if(c!=NULL)
{
if(!push(c))
return -5;
}
c=p->left;
if(c!=NULL)
{
if(!push(c)) return -5;
}
}
return s;
}
int height_s(casa *c)
{
int l=0,r=0;
if(!c) return -1;
l=1+height_s(c->left);
r=1+height_s(c->right);
if(l>r) return l;
else return r;
}

int freemem_s()
{
casa *p,*c;
top=NULL;
if(!root)
return 0;
p=root;
if(!push(p))
return -5;
while(top)
{
p=pop();
 c=p->right;
if(c!=NULL)
{
if(!push(c))
return -5;
}
c=p->left;
if(c!=NULL)
{
if(!push(c)) return -5;
}
free(p);
}
return 1;
}
#include "LAB 10.1.cpp"

int main()
{
casa *t=NULL;
int o=0;
int flag;
char fname[100];
 char str[100];
casa *c;
while(1)
{
system("cls");
printf("\t\t\tMENU\n");
printf("\t//PRELUCRAREA ARBORELUI UTILIZIND
COADA\n");
printf("\t1) Crearea arborelui si completarea lui\n");
printf("\t2) Afisarea arborelui\n");
printf("\t3) Cautarea unui nod in arbore\n");
printf("\t4) Modificarea informatiei unui nod din arbore\n");
printf("\t5) Determinarea numarului de noduri\n");
printf("\t6) Determinarea inaltimii arborelui\n");
printf("\t7) Eliberarea memoriei\n");
printf("\t//PRELUCRAREA ARBORELUI UTILIZIND
STIVA \n");
printf("\t8) Crearea arborelui si completarea lui\n");
printf("\t9) Afisarea arborelui\n");
printf("\t10) Cautarea unui nod in arbore\n");
printf("\t11) Modificarea informatiei unui nod din arbore\n");
printf("\t12) Determinarea numarului de noduri\n");
printf("\t13) Determinarea inaltimii arborelui\n");
printf("\t14) Eliberarea memoriei\n");
printf("\t0) Exit\n");
printf("\nAlegeti optiunea : ");
scanf("%d", &o);
switch(o)
{
case 0: printf("Doriti sa esiti din program? (1/0) : ");
scanf("%d", &flag);
if(flag)
{
return 0;
}
case 1: creat_q();
printf("Memoria a fost alocata cu succes!");
getch();break;
case 2: show_q();
getch();break;
case 3: printf("\nIntrodu adresa casei cautate : ");
fflush(stdin);
gets(fname);
c=search_q(fname);
if(c!=NULL)
{
printf("Adresa : %s\n", c->adresa);
 printf("Telefonul : %d\n", c->telefon);
printf("Suprafata : %.2f\n", c-
>suprafata);
printf("Numarul de odai : %d\n", c-
>numar_odai);
printf("Costul : %.2f\n", c->cost);
}
else
{
printf("Casa cu adresa : '%s' nu
exista", fname);
}
c=NULL;
getch();break;
case 4: printf("Introduceti adresa casei care doriti sa fie
modificata : ");
fflush(stdin);
gets(str);
c=search_q(str);
if(c!=NULL)
{
modify(c);
}
else
{
 printf("Casa cu adresa : '%s' nu a fost
gasita!", str);
}
getch();break;
case 5: printf(" Nodurile arborelui = %d\n",size_q());
getch();break;
case 6: printf(" Inaltimea arborelui este %d \n",
height_q(root)+1);
getch();break;
case 7: freemem_q();
root=NULL;
printf("Memoria a fost eliberata cu succes!\n");
getch();break;
case 8: creat_s();
printf("Memoria a fost alocata cu succes!");
getch();break;
case 9: show_s();
getch();break;
case 10: printf("\nIntrodu adresa casei cautate : ");
fflush(stdin);
gets(fname);
c=search_s(fname);
if(c!=NULL)
{
 printf("Adresa : %s\n", c->adresa);
printf("Telefonul : %d\n", c->telefon);
printf("Suprafata : %.2f\n", c-
>suprafata);
printf("Numarul de odai : %d\n", c-
>numar_odai);
printf("Costul : %.2f\n", c->cost);
}
else
{
printf("Casa cu adresa : '%s' nu
exista", fname);
}
c=NULL;
getch();break;
case 11: printf("Introduceti adresa casei care doriti sa
fie modificata : ");
fflush(stdin);
gets(str);
c=search_s(str);
if(c!=NULL)
{
modify(c);
}
else
 {
printf("Casa cu adresa : '%s' nu a fost
gasita!", str);
}
getch();break;
case 12: printf(" Nodurile arborelui = %d\n",size_s());
getch();break;
case 13: printf(" Inaltimea arborelui este %d \n",
height_s(root)+1);

case 14: freemem_s();

root=NULL;
printf("Memoria a fost eliberata cu succes!\n");
getch();break;

default: printf("Optiune incorecta"); break;

}
}
return 0;
}
Rezultatul Programului:
Analiza rezultatelor și concluzii:
1. Au fost obţinute deprinderi de elaborare, compilare, rulare și
testare a unui program ce contine tablou unidimensional în
limbajul de programare C.
2. Programul da rezultate corecte, veridice din punct de vedere
matematic.
3. Programul exclude probabilitatea situatiilor de conflict, cind
structura contine zero elemente.
4. Programul verifica optiunile alese anterior si exclude efectuarea
pasilor inutili sau imposibili.
5. Programul elaborat acorda utilizatorului un sir de optiuni din care
el poate alege.