Ministerul Educației al Republicii Moldova

Universitatea Tehnică a Moldovei

Catedra Automatica si informatica

RAPORT
Lucrarea de laborator nr.4&5
La Structuri de date si algoritmi

A efectuat:
st. gr. AI-182 Croitoru Tudor

A verificat: Sorin Botnaru

dr., conf.univ.,

Chișinău 2019
 Lucrarea de laborator nr.4&5

Tema: Implementarea tipului de date abstract “Arbore binar geniralizat” in limbajul C.

Algoritmi iterativi si algoritmi recursivi.

Scopul lucrarii: Obținerea deprinderilor de implementare practice in limbajul C a tipului de

date abstract (TDA) “Arbore binar geniralizat”, utilizînd algoritmi iterativi si recursivi.

Sarcina de lucru: De scris trei fișiere în limbajul C pentru implementarea (2 fisiere) si utilizarea
(1 fișier – program cu funcția main) a TDA “Arbore binar geniralizat ”

1. Fișierul antet cu extensia (h) care descrie structura nodului al arborelui binar (conform
variantei din lucrarea de laborator 1) și prototipurile funcțiilor care asigură operațiunile de
prelucrare a arborelui binar. Pentru lucrare de laborator 4 în acest fișier trebuie de adaugat
descrierea structurilor elementelor cozei și a stivei unde vor fi stocate adresele nodurilor ale
arborelui binar precum și prototipurile funcțiilor de inserare și eliminare a elimentului pentru
coada și stiva respectiv.

2. Fisier cu extensia (cpp sau c) care conține codurile (implementările) tuturor funcțiilor
declarate în fișierul antet.

3. Fișierul utilizatorului - programul cu funcția main () pentru prelucrarea arborelui binar cu

afișarea meniului de optiuni pe ecran, si anume: crearea arborelui binar geniralizat împreuna cu
introducerea informației nodurilor arborelui de la tastatură în rejim interactiv, afișarea
informatiei despre nodurile arborelui pe ecran și a adreselor nodului current, copilului sting și
copilului drept al acestora, căutarea nodului după un cîmp informațional al nodului,
determinarea numărului de noduri în arbore, determinarea înalțimei a arborelui, eliberarea
memoriei dinamice alocate pentru arbore, ieșire din program.

În lucrare de laborator 4 funcțiile de prelucrare ale arborelui binar trebuie impementate

folosind algoritm iterativ în 2 versiuni:
a) utilizînd coada - pentru parcurgerea arborelui în largime (parcurgerea arborelui pe niveluri) și
b) utilizînd stiva – pentru parcurgerea arborelui în adîncime (parcurgerea 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 postordine: subarbore stîng(drept)
-> subarbore drept(stîng) -> rădăcină).

În lucrare de laborator 5 funcțiile de prelucrare ale arborelui binar, trebuie implementate

folosind algoritm recursiv pentru parcurgerea arborelui în adîncime: rădăcină -> subarbore
stîng(drept) -> subarbore drept(stîng). Și aici o excepție face funcția de eliberare a memoriei
dinamice alocate pentru arbore (trebuie folosită parcurgerea postordine: subarbore stîng(drept) ->
subarbore drept(stîng) -> rădăcină).
În lucrare de laborator 5 funcția de afișare a informaței despre nodurile arborelui pe ecran,
precum și a adreselor nodului current, copilului sting și copilului drept al acestora trebuie
impementată pentru toate parcurgerile recursive posibile ale arborelui binar.

1
Varianta 10: Stat

Noţiuni teoretice
În informatica, un arbore binar este un arbore în care fiecare nod are cel mult doi succesori (fii).
De obicei, succesorii se numesc „nodul stânga” și „nodul dreapta”. Arborii binari sunt folosiți
mai ales drept arbori binari de căutare sau și la structurile de date de tip heap.
o fiecare nod are 0,1 sau 2 succesori;
o fiecare nod are un singur predecesor, cu exceptia radacinii care nu are niciunul;
o succesorii fiecarui nod sunt ordonati(fiul sting, fiul drept, daca este unul singur trebuie de
mentionat care;
Prin parcurgerea unui arbore se intelege examinarea in mod sistematic a nodurilor sale astfel
incat fiecare nod sa fie atins o singura data.Aceasta actiune este numita si "vizitare" a varfurilor
arborelui,scopul ei fiind de a stationa in fiecare varf pentru a efectua o prelucrare a informatiei
asociata varfului respectiv.Arborele este o structura neliniara de organizare a datelor,iar rolul
traversarii sale este tocmai conceperea unei aranjari liniare a nodurilor in vederea trecerii de la
unul la altul,fructificand avantajul acestei organizari

Parcurgerea arborilor

Preordine Inordine
Se parcurge rădăcina Se parcurge subarborele stâng
Se parcurge subarborele stâng Se parcurge rădăcina
Se parcurge subarborele drept Se parcurge subarborele drept

Postordine
Se parcurge subarborele stâng
Se parcurge subarborele drept
Se parcurge rădăcina

Implementare:
typedef struct arbore{
int info;
struct nod *left, *right;
}arbore;

2
Analiza datelor:

Functia main
a) date intermediare:
nm – variabilă simplă de tip întreg, opțiunea aleasă de utilizator;
fnm - variabilă locala de tip pointer la nod care reprezinta adresa elementului cautat;
nume - variabila de tip pointer la char,denumirea fisierului pentru introducere

int enq(node* v);

Functia pentru inserarea unui element in coada.
Parametri
v – pointer de tip nod, adresa nodului care se introduce în coadă;
date returnabile: functia returnaza 1 daca s-a alocat memorie -1 invers;
Variabile locale
b – pointer de tip coadă, memoria elementului adăugat;

node* deq(void);
Functia pentru eliminarea unui element din coada astfel obtinindui adresa lui.
Parametri nu sunt;
Date returnabile
v – pointer de tip nod (arbore), elementul șters;
Variabile locale
b – pointer de tip coadă, adresa în care se stochează elementul ce urmează să fie șters;

int push(nod* x);

Functia pentru inserarea unui element in stiva.
Parametri
v – pointer de tip nod, adresa nodului care se introduce în stiva;
Date returnabile functia returnaza 1 daca s-a locat memorie -1 invers;
Variabile locale
b – pointer de tip stivă, memoria elementului adăugat;

node *pop(void);
Functia pentru eliminarea unui element din stiva astfel obtinindui adresa lui.
Parametri nu sunt;
Date returnabile
v– pointer de tip nod, elementul șters;
Variabile locale
b – pointer de tip stivă, adresa în care se stochează elementul ce urmează să fie șters;

int show1(void);
Functia pentru afisarea liste de elemente cu ajutorul cozii in latime
Parametri nu sunt;
Date returnabile
functia returneaza 1 daca elementele au fost gasite,0 daca lista este vida
Variabile locale
p,b – pointer de tip nod, variabile pentru prelucrarea listei;

3
int show2(void);
Functia pentru afisarea liste de elemente cu ajutorul stivei in adincime
Parametri nu sunt;
Date returnabile
functia returneaza 1 daca elementele au fost gasite,0 daca lista este vida
Variabile locale
p,b – pointer de tip nod, variabile pentru prelucrarea listei;

int size1(void);
Functia pentru afisarea la ecran la marimii arborelui cu ajutorul cozii
Parametri nu sunt;
Date returnabile
n – variabilă simplă de tip întreg, mărimea arborelui;
Variabile locale
b,p – pointeri de tip nod, variabile pentru prelucrarea listei;

int showRSD(nod *b)

Functia pentru afisarea RSD
Parametri b-pointer de tip nod, adresa rădăcinii;
Date returnabile nu sunt
Variabile locale nu sunt

int size2(void);
Functia pentru afisarea la ecran la marimii arborelui cu ajutorul stivei
Parametri nu sunt;
Date returnabile
s – variabilă simplă de tip întreg, mărimea arborelui;
Variabile locale
c,p – pointeri de tip nod, variabile pentru prelucrarea listei;

int create(void);
Functia pentru crearea arborelui cu ajutorul cozii.
Parametri nu sunt;
Date returnabile returneaza 1 daca elementul a fost creat cu succes,0 invers;
Variabile locale
f – variabilă simplă de tip întreg, răspunsul utilizatorului.
b,p – pointeri de tip carte(arbore), variabile pentru prelucrarea listei;

node*search2(char*v);
Functia pentru cautarea unui element dupa un cimp al structurii cu ajutorul cozii.
Parametri
nume - variabila de tip ponter la char,denumirea elementrului pentru cautare;
Date returnabile
p - pointer de tip nod,adresa elementului găsit;

node* searchRSD(node* b, char key[]);

Functia pentru cautarea unui element dupa un cimp al structurii cu ajutorul cozii.
Parametri
nume - variabila de tip ponter la char,denumirea elementrului pentru cautare;

4
Date returnabile
p - pointer de tip nod,adresa elementului găsit;
Variabile locale
p,b– pointer de tip nod, variabile pentru prelucrarea listei;

int freeSDR(node *b);

Functia pentru eliberarea memoriei
Parametri nu sunt;
Date returnabile returneaza 1 daca elementul a fost creat cu succes,0 invers
Variabile locale
b,p – pointeri de tip carte(arbore), variabile pentru prelucrarea listei

int freemem1(void);
Functia pentru eliberarea memoriei
Parametri nu sunt;
Date returnabile returneaza 1 daca elementul a fost creat cu succes,0 invers
Variabile locale
b,p – pointeri de tip carte(arbore), variabile pentru prelucrarea listei;

void showRSD(node*b)
Functia pentru cautarea unui elementru cu ajutorul recursiei.
Parametri
b-pointer de tip nod, adresa rădăcinii;
Variabile locale nu sunt;

int sizeRSD(nod *b);

Functia pentru afisarea la ecran a marimii arborelui cu ajutorul recuriei.
Parametri
b-pointer de tip nod, adresa rădăcinii;
Date returnabile: mărimea arborelui;
Variabile locale n - variabila simpla de tip întreg,marimea arborelui

int hight(node *b) ;

Functia pentru afisarea la ecran a inaltimii arborelui cu ajutorul recursiei.
Parametri
b-pointer de tip nodmadresa rădăcinii;
Date returnabile
r,l – variabile simple de tip întreg, înălțimea arborelui;
Variabile locale l,r - variabile simple de tip întreg,

void freemem_rsd(nod *c);

Functia pentru eliberarea memoriei
Parametri
c-pointer de tip carte(arbore), adresa rădăcinii;
Date returnabile nu sunt;
Variabile locale nu sunt;

5
Codul programului in limbajul C
Fișierul arbore.h:
#ifndef HEADER_FILE
#define HEADER_FILE

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>

///Structure///
typedef struct node
{
char nume[20];
float pret;
float masa;
int cantitate;
struct node*left;
struct node*right;
} node;

node *root;

typedef struct elq

{node * adr;
struct elq *next;
} elq;
elq *first, *last;

typedef struct els

{node*adr;
struct els*prev;
} els;
els*top;

int enq(node*v);
node*deq(void);

int push(node*v);
node*pop(void);

//functions using queue:

int create1(void);
int show1(void);
node*search1(char*v);
int size1(void);
int freemem1(void);
int hight1(node*b);
int create2(void);
int show2(void);

6
node*search2(char*v);
int size2(void);
int hight2(node*b);
node*create(void);
void showBTW(node*b);
int sizeBTW(node*b);
node *searchBTW(node* b, char key[]);
void freeBTW(node*b);
int hight(node*b);

#endif
Fișierul arbore.c:
#include "arbore.h"
int enq(node*v) // returning value - integer type, parameter - v,pointer to struct node
{
elq*b; // local variable, pointer to struct elq
b=(elq*)malloc(sizeof(*b)); // function call of malloc, allocate memory for element b
if(b==NULL)return 0;
if(first==NULL){first=b;}
else{last->next=b;}
last=b;
b->next=NULL;
b->adr=v;
return 1;
}

node*deq (void) // returning value - b,pointer to struct node

{
node*b; elq*t; // local var, t - pointer to struct t
if(first==NULL) return NULL;
t=first;
first=first->next;
if(first==NULL)last=NULL;
else{first->next;}
b=t->adr;
free(t); // function call for freeing memory
return b;
}
int push(node*v) // returning value - integer type parameter - v, pointer to struct
node
{
els*b;
b=(els*)malloc(sizeof(*b));
if(b==NULL) return 0;
b->prev=top;
top=b;
b->adr=v;
return 1;
}
node*pop(void) // returning value - v, pointer to struct node
{
node*v;

7
 els*b; // pointer to struct els, adress of first element
b=top;
top=b->prev;
v=b->adr;
free(b); // function call for freeing memory
return v;
}
/*
int create1(void) // returning value - integer type
{
node*b, *p; // b,p - local var, pointer to struct node
int f,l; // f - integer type, used for storing answers l - integer type, returning value
for enq(node*v)
printf("Doriti sa creati root (radacina)?(1/0)\n");
scanf("%d",&f);
if(f==0){return -1;}
else{
p=(node*)malloc(sizeof(*p)); // create node of parent
if(p==NULL) return -2;
root=p;
puts("Informatia despre marfa root(radacina):");

printf(" Nume: ");fflush(stdin);gets(b->nume);

printf(" Pret: ");fflush(stdin);scanf("%f", &b ->pret);
printf(" Masa: ");fflush(stdin);scanf("%f", &b ->masa);
printf(" Cantitate: ");scanf("%d", &b ->cantitate);
l=enq(p);
if(l==0) return -3;
while(first!=NULL)
{
p=deq();
printf("Doriti sa creati copilul stang %s? (1/0)",p->nume);
scanf("%d",&f);
if (f==0){p->left=NULL;}
else{b=(node*)malloc (sizeof (*b)); // create node of child
if(b==NULL) return -2;
printf(" Nume: ");fflush(stdin);gets(b->nume);
printf(" Pret: ");fflush(stdin);scanf("%f", &b ->pret);
printf(" Masa: ");fflush(stdin);scanf("%f", &b ->masa);
printf(" Cantitate: ");scanf("%d", &b ->cantitate);
p->left=b;
l=enq(b);
if(l==0) return-3;
}
printf("Doriti sa creati copilul drept %s? (0/1)",p->nume);
scanf("%d",&f);
if (f==0){p->right=NULL;}
else{b=(node*)malloc (sizeof (*b));
if(b==NULL) return -2;
printf(" Nume: ");fflush(stdin);gets(b->nume);
printf(" Pret: ");fflush(stdin);scanf("%f", &b ->pret);
printf(" Masa: ");fflush(stdin);scanf("%f", &b ->masa);

8
 printf(" Cantitate: ");scanf("%d", &b ->cantitate);
p->right=b;
l=enq(b); // function call, insert in the quene
if(l==0) return -4;}
}
}
}

*/

int show1(void) // returning value of integer type

{ node *p,*b; // local var,pointers to struct node, p - node of parent, b-of child
int l;
p=root;
l=enq(p); // insert root in the quene
if(l==0)
return 0;
while(first)
{
p=deq();
printf("Nume : %s\n",p->nume);
printf("Pret : %f\n",p->pret);
printf("Masa : %f\n",p->masa);
printf("Cantitatea : %d\n",p->cantitate);
b=p->left;
if(b!=NULL)
{
l=enq(b);

if(l==0)
return 0;}
b=p->right;
if(b!=NULL)
{
l=enq(b);
if(l==0)
return 0;}
}
}

node*search1(char*v) // returning value - pointer to node struct parameter - pointer to char,

adress of element
{node *p, *b; // pointers to node of parent , of child
int l; // local var, returning value for enq function
p=root;
if (strcmp(p->nume, v)==0) return p; // check if given node are in binary tree
l=enq(p); // insert p in quene
if(!l) return NULL;
while (first) {p=deq();
if (strcmp(p->nume, v)==0) return p;
b=p->left;
if(b) l=enq(b); if(!l) return NULL;

9
b=p->right;
if(b) l=enq(b); if(!l) return NULL;}
return NULL; }

int size1(void) // returning value - integer type

{
int n=0; // local var, returning value
node *p,*b; // adresses of nodes, p - parent , b - child
if(!root) return 0;
p=root;
if(!enq(p )) return -2;
while(first){
p=deq();
n++;
b=p->left;
if(b){
if(!enq(b )) return -2;
}
b=p->right;
if(b ){
if(!enq( b)) return -2;
}
}
return n;
}

int heightbtis(){
int h,l,n,n1,n2,n3;
node *p,*s;
n1=0;
n2=0;
top=NULL;
h=-1;
p=root;
if (!p){
return 0;
}
n=1;
l=push(p);
if (!l) return -1;
while (top){
p=pop();
s=p->left;
if (s){
n1++;
l=push(s);
if (!l) return -2;
}
else{
n2++;
}
s=p->right;

10
 if (s){
n1++;
l=push(s);
if (!l) return -3;
}
else{
n2++;
}
n3=2*n;
if (n3==n1+n2){
h=h+1;
n=n1;
n1=0;
n2=0;
}
}
return h;
}

int freemem1(void) // returning value - integer type

{
node*p; node*b; // pointers to struct node, adresse of parent and child nodes
int l; // local var, returning value for function enq
p=root;
l=enq(p); // insert root in the quene
if(l==0) return 0;
while(first)
{
p=deq(); // geting adress of node which was deleted from quene
b=p->left;
if(b){l=enq(b);
if(l==0);return 0;}
free(p);} // call for freeing memory
}
/*
///////////////////second////////////
int create2(void)
{
node*b, *p; // b,p - local var, pointer to struct node
int f,l; // f - integer type, used for storing answers l - integer type, returning value for
push function

printf("Creaza radacina?(1/0)\n");
scanf("%d",&f);
if(f==0){return -1;}
else{
p=(node*)malloc(sizeof(*p)); //create parent node
if(p==NULL) return -2;
root=p;
printf(" Nume: ");fflush(stdin);gets(b->nume);
printf(" Pret: ");fflush(stdin);scanf("%f", &b ->pret);
printf(" Masa: ");fflush(stdin);scanf("%f", &b ->masa);

11
 printf(" Cantitate: ");scanf("%d", &b ->cantitate);
l=push(p);
if(l==0) return -3;
while(top!=NULL)
{
p=pop(); // p get adress of node which was deleted from quene
printf("Doriti sa creati copilul stang %s? (1/0)",p->nume);
scanf("%d",&f);
if (f==0){p->left=NULL;}
else{b=(node*)malloc (sizeof (*b)); //create child node
if(b==NULL) return -2;
printf(" Nume: ");fflush(stdin);gets(b->nume);
printf(" Pret: ");fflush(stdin);scanf("%f", &b ->pret);
printf(" Masa: ");fflush(stdin);scanf("%f", &b ->masa);
printf(" Cantitate: ");scanf("%d", &b ->cantitate);
p->left=b;
l=push(b);
if(l==0) return-3; }

printf(" Doriti sa creati copilul drept %s? (0/1)",p->nume);

scanf("%d",&f);
if (f==0){p->right=NULL;}
else{b=(node*)malloc (sizeof (*b));
if(b==NULL) return -2;
printf(" Nume: ");fflush(stdin);gets(b->nume);
printf(" Pret: ");fflush(stdin);scanf("%f", &b ->pret);
printf(" Masa: ");fflush(stdin);scanf("%f", &b ->masa);
printf(" Cantitate: ");scanf("%d", &b ->cantitate);
p->right=b;
l=push(b);
if(l==0) return -4;}
}
}}
*/
int show2(void) // returning value of integer type

{ node *p,*b; // local var,pointers to struct node, p - node of parent, b-of chil
int l; // returning value for function push
p=root;
l=push(p); // insert p in the stack
if(l==0)
return 0;
while(top)
{
p=pop();
printf("Numele : %s\n",p->nume);
printf("Pret : %f\n",p->pret);
printf("Masa : %f\n",p->masa);
printf(" Cantitate : %d\n",p->cantitate);
b=p->right;
if(b!=NULL)
{

12
 l=push(b);
if(l==0)
return 0;}
b=p->left;
if(b!=NULL)
{
l=push(b);
if(l==0)
return 0;}
}
}

node*search2(char*v) // returning value - pointer to struct node, parameter - pointer to char,

adress of element
{node *p, *b; //local var,pointers to struct node, p - node of parent, b-of chil
int l;
p=root;
if (strcmp(p->nume, v)==0) return p;
l=push(p); if(!l) return NULL;
while (top) {p=pop();
if (strcmp(p->nume, v)==0) return p;
b=p->left;
if(b) l=push(b); if(!l) return NULL;
b=p->right;
if(b) l=push(b); if(!l) return NULL;}
return NULL; }

int size2(void){ // returning value - integer type

int n=0; // local variable - integer type, returning value
node *p,*b; // local var,pointers to struct node, p - node of parent, b-of chil
if(!root) return 0;
p=root;
if(!push(p )) return -2;
while(top){
p=pop();
n++;
b=p->left;
if(b){
if(!push(b )) return -2;
}
b=p->right;
if(b ){
if(!push( b)) return -2;
}
}
return n;
}

node*create(void) // returning value - pointer to node struct

{
node*b; // local var, returing value - pointer to node struct, adress
int f; // local var, int type - 1/0 values can take

13
 b=(node*)malloc(sizeof(*b)); // create the root
if(b==NULL) return NULL;
printf(" Da-ti informatia despre root(radacina)\n");
printf(" Nume: ");fflush(stdin);gets(b->nume);
printf(" Pret: ");fflush(stdin);scanf("%f", &b ->pret);
printf(" Masa: ");fflush(stdin);scanf("%f", &b ->masa);
printf(" Cantitate: ");scanf("%d", &b ->cantitate);

printf("Doriti sa creati copilul stang %s?(0/1)", b->nume);

scanf("%d",&f);
if(f){b->left=create();} // function call , recursive
else
{b->left=NULL;}
printf("Doriti sa creati copilul drept %s?(0/1)", b->nume);
scanf("%d", &f);
if(f){b->right=create(); } else // function call, recursive
{b->right=NULL;}
root=b;
return b;
}

void showRSD(node*b) // no returning value, parameter - pointer to node

{
if (b==NULL) return;
printf("Nume : %s\n",b->nume);
printf("Pret : %f\n",b->pret);
printf("Masa : %f\n",b->masa);
printf("Cantitatea : %d\n",b->cantitate);
showRSD(b->left); //fucntion call, recursive
showRSD(b->right); // function call, recursive

int sizeRSD(node*b) // returning value - integer type

// parameter - pointer to struct node, adress
{ int n; // local var, returning value of function
if(b==NULL)return 0;
n=1+sizeRSD(b->left)+sizeRSD(b->right); // recursive function call
return n;
}

node *searchRSD(node* b, char key[]) // returning value - pointer to struct node

// parameters - c,pointer to node struct, adress of first node
// key - char type, searched element (node)

{
node*t=NULL; // returning value, local var - pointer to node
if(b==NULL) return NULL;
if (strcmp(b->nume,key)==0) return b;
t=searchRSD(b->left, key); // recursive function call
if (t) return t;

14
t=searchRSD(b->right, key); // recursive function call
if (t) return t;
return NULL;
}

void freeSDR(node *b) // no returning value, parameter - pointer to struct node

{
if(b==NULL) return;
freeSDR(b->left); // recursive function call for left subtree
freeSDR(b->right); // recursive function call for right subtree
free(b);} // freeing the root

int hight(node*b) // returning value - integer type, paramater - pointer to struct node,
adress of first element from binary tree
{
int l,r; // local var, int type, returing values for function r - right subtree ; l - left subtree
if(!b)return -1;
l=1+hight(b->left);
r=1+hight(b->right);
if (r>=l)
{return (1+l);} else {return(1+r);}
}
Fisierul main.c:
#include "arbore.c"

int main ()
{
int fnm,lung,nm,f, l;
char v[10];
node*b;
node*p;
Tree:
while(1)

{
system("cls");
puts("1. Algoritmi iterativi ");
puts("2. Algoritmi recursivi");
puts("0. Exit");
scanf("%d", &nm);
system("cls");
switch(nm)
{
case 1:
system("cls");
while (1) {
system("cls");
system (" color e");
puts(" Algorimti iterativi folosind coada \n");
puts("1. Formarea si introducerea arborelui binar");
puts("2. Partajarea arborelui binar");
puts("3. Cautarea unui nod");

15
 puts("4. Numarul de noduri");
puts("5. Inaltimea arborelui");
puts("6. Eliberarea memoriei");
puts(" Algorimti iterativi folosind stiva \n");
puts("7. Formarea si introducerea arborelui binar");
puts("8. Partajarea arborelui");
puts("9. Cautarea unui node");
puts("10. Numarul de noduri");
puts("11. Inaltimea nodului");
puts("12. Eliberarea memoriei");
puts("0. Exit");
scanf("%d",&nm);

switch(nm) {
case 1:
system("cls");
system (" color a");

create();
puts("\nTo continue press enter");
getch();
break;
case 2:
system("cls");
if(root==NULL){printf("Arborele este NULL");}else
{puts("Arborele este\n");
show1();}
getch();
break;
case 3:
system("cls");
printf("Da-ti numele marfei pe care o doriti sa o cautati \n");
fflush(stdin);
gets(v);
p=search1(v);
if(p==NULL)
{
printf("Nu exista asa marfa in lista\n");
} else
printf(" Nume: ");fflush(stdin);gets(b->nume);
printf(" Pret: ");fflush(stdin);scanf("%f", &b ->pret);
printf(" Masa: ");fflush(stdin);scanf("%f", &b ->masa);
printf(" Cantitate: ");scanf("%d", &b ->cantitate);
puts("\nTo continue press enter");
getch();
break;
case 4:
system("cls");
lung=size1();
printf("The tree has %d nodes",lung);
puts("\nTo continue press enter");
getch();

16
 break;
case 5:
system("cls");
printf("Inaltimea arborelui %d \n", heightbtis());
puts("Press Enter to continue");
getch();
break;
case 6:
system("cls");
freemem1();
root=NULL;
puts("Memory was eliberated!");
printf("\nTo continue press enter");
getch();
break;
case 7:
system("cls");
create();
puts("\n To continue press enter");
getch();
break;
case 8:
system("cls");
if(root==NULL){printf("Arborele este NULL");}else
{puts("Lista de noduri\n");
show2();}
printf("\nTo continue press enter");
getch();
break;
case 9:
system("cls");
printf("Da-ti denumirea margfei pe care o doriti sa o cautati\n");
fflush(stdin);
gets(v);
p=search2(v);
if(p==NULL)
{
printf("Asa node nu exista\n");
} else
{
printf("Numele : %s\n",p->nume);
printf("Pret : %f\n",p->pret);
printf("Masa : %f\n",p->masa);
printf(" Cantitate : %d\n",p->cantitate);
puts("To continue press enter");
}
getch();
break;
case 10:
system("cls");
l=size2();
printf("Arborele are %d noduri",l);

17
 printf("\nTo continue press enter");
getch();
break;
case 11:
system("cls");
printf("Inaltimea arborelui este de %d \n", heightbtis());
puts("Press Enter to continue");
getch();
break;
case 12:
system("cls");
freemem1();
root=NULL;
puts("Memoria a fost eliberata cu succes!");
printf("\nTo continue press enter");
getch();
break;
case 0:
system("cls");
goto Tree;
break;
getch();
break;
}}
case 2:
system("cls");
while (1) {
system("cls");
puts (" Algoritmi recursivi \n");
puts("13. Crearea si introducerea arborelui binar");
puts("14. Afisarea RSD a arborelui");
puts("15. Numarul de noduri");
puts("16. Cautarea unui node");
puts("17. Inaltimea nodului");
puts("18. Eliberarea memoriei");
puts("0. Exit");
scanf("%d",&nm);
system("cls");
switch (nm)
{
case 13:
system("cls");

printf("Doriti sa creati radacina?(1/0)");

scanf("%d",&f);
if(f){root=create();}
puts("\n To continue press enter");
getch();
break;
case 14:
system("cls");
if(!root) {puts("Arborele nu a fost creat");}

18
 else{
showRSD(root);}
puts("\n To continue press enter");
getch();
break;
case 15:
system("cls");
lung=sizeRSD(root);
printf("Arborele are %d noduri",lung);
puts("\n To continue press enter");
getch(); break;
case 16:
system("cls");
puts("Introduce-ti numele nodului ce il cautati");
fflush(stdin); gets(v);
b=searchRSD(root,v);
if (b==NULL) {puts("Asa node nu exista in lista");
puts("\n To continue press enter");
getch();
break;}
else{
printf("Numele : %s\n",p->nume);
printf("Pret : %f\n",p->pret);
printf("Masa : %f\n",p->masa);
printf("Cantitate : %d\n",p->cantitate);
}
puts("\n To continue press enter");
getch();
break;
case 17:
system("cls");
l=hight(root);
printf("Arborele are inaltimea de %d",l);
puts("\n To continue press enter");
getch();
break;
case 18:
system("cls");
freeSDR(root);
root=NULL;
puts("Memoria a fost eliberata cu succes");
puts("\n To continue press enter");
getch();
break;

case 0:
break;
default:
puts("Nu exista asa optiune\n");
getch();
}
}

19
 break;
}

}
}

Screen Shot-uri:
Menu

Crearea arborelui

20
Afisarea

Marimea arborelui

21
Inaltimea arborelui

Cautarea unui nod

Eliberaraea memoriei

Crearea arborelui

Afisarea

22
Marimea arborelui

Inaltimea arborelui

Cautarea uui nod

Eliberarea memoriei

---------------------------------------------- Folosind recursia -----------------------------------------------

23
Crearea

Afisarea RSD

Marimea arborelui

24
Inaltimea arborelui

Cautarea unui nod

Eliberarea memoriei

Concluzii:
În urma efectuării acestui laborator, am elaborat un program de prelucrare a unui arbore
binar și am însușit modul de modul de repartizare a codului în fișiere, ceea ce permite ca codul să
fie mai ușor de citit și redactat. Am elaborat un meniu prin care utilizatorul poate comunica cu
programul elaborat și am implementat cele mai utile funcții de prelucrare a arborelui binar.

Bibliografie:

25
1. Conspectul prelegerilor cursului Programarea Calculatoarelor. Lector dr., conf. univ.
M.Kulev. Chișinău: UTM, 2014.
2. http://www.cprogramming.com/tutorial/c/lesson15.html
3. http://www.cplusplus.com/reference/cstdio/fwrite/?kw=fwrite (03,12,2015)
4. http://problemegratis.blogspot.com/2013/03/vectori-caractere-string.html (03,12,2015)

26