Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

Catedra Informatica Aplicată

RAPORT
Lucrarea de laborator nr.4-5
la Structuri de date si algoritmi

A efectuat:
st. gr. SI-151 D.Cucu

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

Chişinău 2016
0
 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 de bază

Un arbore binar e o multime de n >= 0 noduri, care daca nu este vida, contine un nod numit
radacina, restul nodurilor formand doi arbori disjuncti numiti subarborele stang si subarborele
drept.

Aceasta structura de date e importanta pentru ca e usor de reprezentat si prelucrat, orice arbore
putand fi transformat in arbore binar .

Principalele modalitati de parcurgere ale unui arbore binar sunt:

A) Arborii binari pot fi parcursi prin metode specifice grafurilor: in adancime, latime.

B) Metode specifice arborilor binari :

 Parcurgerea in inordine (stanga –varf – dreapta SVD) – se parcurge mai intai subarborele
stang, apoi varful, apoi subarborele drept.
 Parcurgerea in preordine (varf- stanga – dreapta VSD) – se parcurge mai intai varful,
apoi subarborele stang, apoi subarborele drept.
 Parcurgerea in postordine (stanga – dreapta – varf SDV) – se parcurge mai intai
subarborele stang, apoi subarborele drept si la sfarsit varful.

Solutiile de parcurgere ale arborelui din figura urmatoare :

parcurgere svd - in inordine

42516378
parcurgere vsd - in preordine
12453678
parcurgere sdv - in postordine
45268731

Analiza datelor
Functia main:
comand- variabila locala, variabila de tip integer, comanda pentru alegere din meniu
m,m1,m2,m3-variabila locala de tip integer, indicele ciclului respectiv
t- variabila locala returnabila de tip structura, adresa elementului de cautat
fname-variabila locala de tip character, adresa denumirii statului introdus de la tastatura

2
 Functia: creat_q(),creat_s(),creat_r() si show_q(),show_s(), show_r()
p- variabila locala de tip structura, adresa nodului parinte
c-variabila locala de tip structura, adresa nodului copil
f- variabila locala de tip integer,variabila dedicate pentru alegerea optiunii

Functia: inq(nod*v) si delq()

c-variabila locala de tip structura, adresa elementului inserat(sters) in coada
v- variabila locala de tip structura

Functia: pop(), push(nod*v)

c-variabila locala de tip structura, adresa elementului inserat(sters) in stiva
v- variabila locala de tip structura

Functia: search_s(),search_q(),search_r()
p- variabila locala de tip structura, adresa nodului parinte
c-variabila locala de tip structura, adresa nodului copil
t- variabila locala de tip pointer la structura, adresa elementului de cautat
Functia: freemem_q(),freemem_s(),freemem_r(nod *c)
p- variabila locala de tip structura, adresa nodului parinte
c-variabila locala de tip structura, adresa nodului copil

Functia: size_q(),size_s(), size_r(nod *c)

p- variabila locala de tip structura, adresa nodului parinte
c-variabila locala de tip structura, adresa nodului copil
s- variabila locala de tip integer, numarul de elemente

Codul programului:
Fisierul “struct.h”

//Arbore
typedef struct nod{
char denumire[40];
char capitala[40];
int sup;
int nl;
float pib;
struct nod *left;
struct nod *right;
}nod;

nod *root;

//Coada
typedef struct elq{
nod *adrnod;
struct elq *next;
}elq;

elq *first;
elq *last;

//Stiva
3
typedef struct els{
nod *adrnod;
struct els *prev;
}els;

els *top;

//Prototipuri
void find_error(int ord);
int inq(nod *v);
nod* delq();
int push(nod *v);
nod* pop();
int creat_q();
int creat_s();
int creat_r();
int show_q();
int show_s();
void show_r(nod *c);
nod* search_q(char *fname);
nod* search_s(char *fname);
nod* search_r(nod* c, char *fname);
int size_q();
int size_s();
int size_r(nod *c);
void freemem_r(nod *c);
int freemem_q();
int freemem_s();
int height_r(nod *c);
Fisierul “funct.cpp”
#include <stdio.h> } else {
#include <stdlib.h> first=c->next;
#include <string.h> }
#include "struct.h" v=c->adrnod;
#define pause printf("\n\n"); system("pause"); free(c);
return v;
}
//inserarea elementului in coada
int inq(nod *v){ //inserarea elementului in stiva
elq *c; int push(nod *v){
c=(elq*)malloc(sizeof(elq)); els *c;
if(!c) return 0; c=(els*)malloc(sizeof(els));
if(!first){ if(!c) return 0;
first = c; c->prev=top;
} else { c->adrnod=v;
last->next=c; top=c;
} return 1;
last=c; }
c->next=NULL;
c->adrnod=v; //stergerea elementului din stiva
return 1; nod* pop(){
} els *c=top;
nod *v;
//stergerea elementului din coada top=c->prev;
nod* delq(){ v=c->adrnod;
elq *c=first; free(c);
nod *v; return v;
if(c == last){ }
first=last=NULL;

4
//crearea arborelui in coada
int creat_q(){ //Afisarea in coada
int f; int show_q(){
nod *c,*p; nod *p,*c;
first=last=NULL; first=last=NULL;
printf("Doriti sa creati radacina arborelui (1/0)? :\n "); if(!root) return 0;
scanf("%d",&f); p=root;
if(f){ if(!inq(p)) return -2;
c=(nod*)malloc(sizeof(nod)); printf("Lista Statelor\n\n");
if(!c) return -1; while(first){
printf("\nIntroduceti datele :\n");\ p=delq();
printf("Denumirea : "); scanf("%s",&c-
>denumire);\ printf("=====================================
printf("Capitala : "); scanf("%s",&c- =============\n\n");
>capitala);\ printf("Denumire %s\n",p-
printf("Suprafata : "); scanf("%d",&c->sup);\ >denumire);
printf("Numarul de locuitori : "); printf("Capitala %s\n",p->capitala);
scanf("%d",&c->nl);\ printf("Suprafata %d\n",p->sup);
printf("PIB-ul : "); scanf("%f",&c- printf("Numarul de locuitori %d\n",p->nl);
>pib); printf("PIB-ul %.2f\n\n",p->pib);
if(!inq(c)) return -2; printf("Adresa elementului curent %p\n",p);
root = c; printf("Adresa copilului drept %p\n",p-
}else { >right);
root = NULL; printf("Adresa copilului sting %p\n",p->left);
} c=p->left;
while(first){ if(c){
p = delq(); if(!inq(c)) return -2;
printf("Doriti sa creati copilul sting al nodului }
%s (1/0)? : \n",p->denumire); c=p->right;
scanf("%d",&f); if(c){
if(f){ if(!inq(c)) return -2;
c=(nod*)malloc(sizeof(nod)); }
if(!c) return -3; }
printf("\nIntroduceti datele :\n");\ return 1;
printf("Denumirea : "); scanf("%s",&c- }
>denumire);\
printf("Capitala : "); scanf("%s",&c- //cautarea in coada
>capitala);\ nod* search_q(char *fname){
printf("Suprafata : "); scanf("%d",&c->sup);\ nod *p,*c;
printf("Numarul de locuitori : "); first=last=NULL;
scanf("%d",&c->nl);\ if(!root) return NULL;
printf("PIB-ul : "); scanf("%f",&c- p=root;
>pib); if(!inq(p)) return NULL;
p->left=c; while(first){
if(!inq(c)) return -2; p=delq();
} else { if(!strcmp(p->denumire,fname)) return p;
p->left=NULL; c=p->left;
} if(c){
printf("De creat copilul drept al nodului %s (1/0)? : if(!inq(c)) return NULL;
\n",p->denumire); }
scanf("%d",&f); c=p->right;
if(f){ if(c){
c=(nod*)malloc(sizeof(nod)); if(!inq(c)) return NULL;
if(!c) return -3; }
printf("\nIntroduceti datele :\n");\ }
printf("Denumirea : "); scanf("%s",&c- return NULL;
>denumire);\ }
printf("Capitala : "); scanf("%s",&c-
>capitala);\ //marimea in coada
printf("Suprafata : "); scanf("%d",&c->sup);\ int size_q(){
printf("Numarul de locuitori : "); int s=0;
scanf("%d",&c->nl);\ nod *p,*c;
printf("PIB-ul : "); scanf("%f",&c- first=last=NULL;
>pib); if(!root) return 0;
p->right = c; p=root;
if(!inq(c)) return -2; if(!inq(p)) return -2;
} else { while(first){
p->right = NULL; p=delq();
} s++;
} c=p->left;
return 1; if(c){
} if(!inq(c)) return -2;
5
 } printf("PIB-ul : "); scanf("%f",&c-
c=p->right; >pib);
if(c){ p->right = c;
if(!inq(c)) return -2; if(!push(c)) return -5;
} } else {
} p->right = NULL;
return s; }
} printf("Doriti sa creati copilul sting al nodului %s
(1/0)? : \n",p->denumire);
//eliberarea memoriei in coada fflush(stdin);
int freemem_q(){ scanf("%d",&f);
nod *p,*c; if(f){
first=last=NULL; c=(nod*)malloc(sizeof(nod));
if(!root) return 0; if(!c) return -3;
p=root; printf("\nIntroduceti datele :\n");\
if(!inq(p)) return -2; printf("Denumirea : "); scanf("%s",&c-
while(first){ >denumire);\
p=delq(); printf("Capitala : "); scanf("%s",&c-
c=p->left; >capitala);\
if(c){ printf("Suprafata : "); scanf("%d",&c->sup);\
if(!inq(c)) return -2; printf("Numarul de locuitori : ");
} scanf("%d",&c->nl);\
c=p->right; printf("PIB-ul : "); scanf("%f",&c-
if(c){ >pib);
if(!inq(c)) return -2; p->left=c;
} if(!push(c)) return -5;
free(p); } else {
} p->left=NULL;
return 1; }
} }
}
//crearea arborelui in stiva return 1;
int creat_s(){ }
nod *p, *c;
int f; //afisarea in stiva
root=NULL; int show_s(){
top=NULL; nod *p,*c;
printf("Doriti sa creati radacina arborelui (1/0)? :\n "); top=NULL;
fflush(stdin); if(!root) return 0;
scanf("%d",&f); p=root;
if(f){ if(!push(p)) return -5;
c=(nod*)malloc(sizeof(nod)); printf("Lista Statelor\n\n");
if(!c) return -1; while(top){
printf("\nIntroduceti datele :\n");\ p=pop();
printf("Denumirea : "); scanf("%s",&c-
>denumire);\ printf("=====================================
printf("Capitala : "); scanf("%s",&c- ======\n\n");
>capitala);\ printf("Denumire %s\n",p-
printf("Suprafata : "); scanf("%d",&c->sup);\ >denumire);
printf("Numarul de locuitori : "); printf("Capitala %s\n",p->capitala);
scanf("%d",&c->nl);\ printf("Suprafata %d\n",p->sup);
printf("PIB-ul : "); scanf("%f",&c- printf("Numarul de locuitori %d\n",p->nl);
>pib); printf("PIB-ul %.2f\n\n",p->pib);
if(!push(c)) return -5; printf("Adresa elementului curent %p\n",p);
root=c; printf("Adresa copilului drept %p\n",p-
while(top){ >right);
p=pop(); printf("Adresa copilului sting %p\n",p->left);
printf("Doriti sa creati copilul drept al nodului %s c=p->right;
(1/0)? :\n ",p->denumire); if(c!=NULL){
fflush(stdin); if(!push(c)) return -5;
scanf("%d",&f); }
if(f){ c=p->left;
c=(nod*)malloc(sizeof(nod)); if(c!=NULL){
if(!c) return -3; if(!push(c)) return -5;
printf("\nIntroduceti datele :\n");\ }
printf("Denumirea : "); scanf("%s",&c- }
>denumire);\ pause
printf("Capitala : "); scanf("%s",&c- return 1;
>capitala);\ }
printf("Suprafata : "); scanf("%d",&c->sup);\
printf("Numarul de locuitori : "); //marimea in stiva
scanf("%d",&c->nl);\ int size_s(){
6
nod *p,*c; fflush(stdin);
int s=0; scanf("%d",&f);
top=NULL; if(f){
if(!root) return 0; c=(nod*)malloc(sizeof(nod));
p=root; if(!c) return -1;
if(!push(p)) return -5; printf("\nIntroduceti datele :\n");\
while(top){ printf("Denumirea : "); scanf("%s",&c-
p=pop(); s++; >denumire);\
c=p->right; printf("Capitala : "); scanf("%s",&c-
if(c!=NULL){ >capitala);\
if(!push(c)) return -5; printf("Suprafata : "); scanf("%d",&c->sup);\
} printf("Numarul de locuitori : ");
c=p->left; scanf("%d",&c->nl);\
if(c!=NULL){ printf("PIB-ul : "); scanf("%f",&c-
if(!push(c)) return -5; >pib);
} if(!push(c)) return -5;
} root=c;
return s; while(top){
} p=pop();
printf("Doriti sa creati copilul drept al nodului %s
//cautarea in stiva (1/0)? :\n ",p->denumire);
nod* search_s(char *fname){ fflush(stdin);
nod *p,*c; scanf("%d",&f);
top=NULL; if(f){
if(!root) return NULL; c=(nod*)malloc(sizeof(nod));
p=root; if(!c) return -3;
if(!push(p)) return NULL; printf("\nIntroduceti datele :\n");\
while(top){ printf("Denumirea : "); scanf("%s",&c-
p=pop(); >denumire);\
if(!strcmp(fname,p->denumire)) return p; printf("Capitala : "); scanf("%s",&c-
c=p->right; >capitala);\
if(c!=NULL){ printf("Suprafata : "); scanf("%d",&c->sup);\
if(!push(c)) return NULL; printf("Numarul de locuitori : ");
} scanf("%d",&c->nl);\
c=p->left; printf("PIB-ul : "); scanf("%f",&c-
if(c!=NULL){ >pib);
if(!push(c)) return NULL; p->right = c;
} if(!push(c)) return -5;
} } else {
return NULL; p->right = NULL;
} }
printf("Doriti sa creati copilul sting al nodului %s
//eliberarea memoriei in stiva (1/0)? : \n",p->denumire);
int freemem_s(){ fflush(stdin);
nod *p,*c; scanf("%d",&f);
top=NULL; if(f){
if(!root) return 0; c=(nod*)malloc(sizeof(nod));
p=root; if(!c) return -3;
if(!push(p)) return -5; printf("\nIntroduceti datele :\n");\
while(top){ printf("Denumirea : "); scanf("%s",&c-
p=pop(); >denumire);\
c=p->right; printf("Capitala : "); scanf("%s",&c-
if(c!=NULL){ >capitala);\
if(!push(c)) return -5; printf("Suprafata : "); scanf("%d",&c->sup);\
} printf("Numarul de locuitori : ");
c=p->left; scanf("%d",&c->nl);\
if(c!=NULL){ printf("PIB-ul : "); scanf("%f",&c-
if(!push(c)) return -5; >pib);
} p->left=c;
free(p); if(!push(c)) return -5;
} } else {
return 1; p->left=NULL;
} }
}
}
//crearea recursiv return 1;
int creat_r(){ }
nod *p, *c; //afisarea recursiv
int f; void show_r(nod *c){
root=NULL; if(!c){
top=NULL; return;
printf("Doriti sa creati radacina arborelui (1/0)? :\n "); }
7
 t=search_r(c->left,fname);
printf("===================================== if (t) return t;
=\n\n"); t=search_r(c->right,fname);
printf("Denumirea %s\n",c->denumire); if (t) return t;
printf("Capitala %s\n",c->capitala); return NULL;
printf("Suprafata %d\n",c->sup); }
printf("Numarul de locuitori %d\n",c->nl);
printf("PIB-ul %.2f\n\n",c->pib); //marimea recursiv
printf("Adresa elementului curent %p\n",c); int size_r(nod *c){
printf("Adresa copilului drept %p\n",c->right); static int n=0;
printf("Adresa copilului sting %p\n",c->left); if(!c) return n;
show_r(c->left); n++;
show_r(c->right); size_r(c->left);
} size_r(c->right);
return n;
//eliberarea memoriei recursiv }
void freemem_r(nod *c){
if(!c) return; //inaltimea arborelui
freemem_r(c->left); int height_r(nod *c){
freemem_r(c->right); int l,r;
free(c); if(!c) return -1;
} l=height_r(c->left);
r=height_r(c->right);
//cautarea recursiv if(l>r)return(l+1);
nod* search_r(nod* c, char *fname){ else{return(r+1);
nod* t=NULL; }
if(!c) return NULL; }
if (!strcmp(c->denumire,fname)) return c;

Fisierul “main.cpp”
#include "funct.cpp" }break;
int main(){ }
int comand,m=1,m1=0,m2=0,m3=0; system("cls"); fflush(stdin);
nod *t=NULL; printf("\tAlegeti modul de lucru :\n");
char fname[10]; printf(" 1. Coada\n");
while(1){ printf(" 2. Stiva\n");
fflush(stdin); printf(" 3. Recursie\n");
while(m){m=0; system("cls"); fflush(stdin); printf(" 4. Meniul de introducere a datelor\n");
printf("\t\tCrearea printf(" 0. Exit\n\n");
arborelui :\n"); printf("Comand >> ");
scanf("%d",&comand);
system("cls");
printf("\t**************************************** switch(comand){
***\n"); case 0: exit(0); break;
printf(" \t\t| 1.| Utilizind case 1: m1=1; break;
coada\n"); case 2: m2=1; break;
printf(" \t\t| 2.| Utilizind case 3: m3=1; break;
stiva\n"); case 4: m=1; break;
printf(" \t\t| 3.| Utilizind default: printf("\a\nAti introdus o comanda
functie recursiva\n "); gresita!\n"); break;
printf(" \t\t| 0.| Exit\n "); }

while(m1){ system("cls"); fflush(stdin);

printf("\t**************************************** printf("\t\tPrelucrarea arborelui binar folosind coada!\n");
**\n");
printf("Comand >> "); printf("\t\t===================================
fflush(stdin); ========\n");
scanf("%d",&comand); printf(" 1. Afisarea informatiei despre nodurile
system("cls"); arborelui \n");
switch(comand){ printf(" 2. Cautarea nodului dupa denumirea statului \n");
case 0: exit(0); printf(" 3. Marimea arborelui\n");
break; printf(" 4. Inaltimea arborelui!\n");
case 1: creat_q(); printf(" 5. Eliberarea memoriei\n");
break; printf(" 6. Alege modul de lucru\n\n");
case 2: creat_s(); printf(" 0. Exit\n\n");
break; printf("Comand >> ");
case 3: creat_r(); scanf("%d",&comand);
break; system("cls");
default: switch(comand){
printf("\a\nAti introdus o comanda gresita!\n"); case 0: exit(0); break;
m=1; break; case 1:

8
 show_q(); break; } else {
case 2: printf("Nu sa gasit nici un stat
printf("Introduceti denumirea statului cu asa nume!\a");
pentru cautare : "); } break;
fflush(stdin); scanf("%s",&fname); case 3:
t=search_q(fname); printf("Arborele are noduri ");
if(t){ find_error(size_s()); break;
case 4:
printf("Inaltimea arborelui este
printf("===================================== %d",height_r(root));
=\n\n"); break;
printf("Denumire %s\n",t->denumire); case 5:freemem_s(); root=NULL;
printf("Capitala %s\n",t->capitala); printf("Memoria s-a eliberat cu succes!");
printf("Suprafata %d\n",t->sup); break;
printf("Numarul de locuitori %d\n",t->nl); case 6: m2=0; break;
printf("PIB-ul %.2f\n",t->pib); default: printf("\a\nAti introdus o comanda
} else { gresita!\n"); break;
printf("Nu sa gasit nici un stat } pause
cu asa nume!\a"); }
} break; while(m3){ system("cls"); fflush(stdin);
case 3: printf("\t\tPrelucrarea arborelui binar recursiv!\n");
printf("Arborele are noduri");
find_error(size_q()); break; printf("\t\t===================================
case 4: ========\n");
printf("Inaltimea arborelui este printf(" 1. Afisarea informatiei despre nodurile
%d",height_r(root)); arborelui \n");
break; printf(" 2. Cautarea nodului dupa denumirea statului \n");
case 5: printf(" 3. Marimea arborelui\n");
freemem_q(); root=NULL; printf(" 4. Inaltimea arborelui!\n");
printf("Memoria s-a eliberat cu printf(" 5. Eliberarea memoriei\n");
succes!"); printf(" 6. Alege modul de lucru\n\n");
break; printf(" 0. Exit\n\n");
case 6: m1=0; break; printf("Comand >> ");
default: printf("\a\nAti introdus o comanda scanf("%d",&comand);
gresita!\n"); break; system("cls");
} pause switch(comand){
} case 0: exit(0); break;
while(m2){ system("cls"); fflush(stdin); case 1:
printf("\t\tPrelucrarea arborelui binar folosind stiva!\n"); show_r(root); break;
case 2:
printf("\t\t=================================== printf("Introduceti denumirea statului
========\n"); pentru cautare : ");
printf(" 1. Afisarea informatiei despre nodurile fflush(stdin); scanf("%s",&fname);
arborelui \n"); t=search_r(root,fname);
printf(" 2. Cautarea nodului dupa denumirea statului \n"); if(t){
printf(" 3. Marimea arborelui\n");
printf(" 4. Inaltimea arborelui!\n");
printf(" 5. Eliberarea memoriei\n"); printf("=====================================
printf(" 6. Alege modul de lucru\n\n"); =\n\n");
printf(" 0. Exit\n\n"); printf("Denumire %s\n",t->denumire);
printf("Comand >> "); printf("Capitala %s\n",t->capitala);
scanf("%d",&comand); printf("Suprafata %d\n",t->sup);
system("cls"); printf("Numarul de locuitori %d\n",t->nl);
switch(comand){ printf("PIB-ul %.2f\n",t->pib);
case 0: exit(0); break; } else {
case 1: printf("Nu sa gasit nici un stat
show_s(); break; cu asa nume!\a");
case 2: } break;
printf("Introduceti denumirea statului case 3:
pentru cautare : \n"); printf("Arborele are noduri ");
fflush(stdin); scanf("%s",&fname); find_error(size_r(root)); break;
t=search_s(fname); case 4:
if(t){ printf("Inaltimea arborelui este
%d",height_r(root));
break;
printf("===================================== case 5:
=\n\n"); freemem_r(root); root=NULL;
printf("Denumire %s\n",t->denumire); printf("Eliberarea memoriei a avut loc
printf("Capitala %s\n",t->capitala); cu succes!\a");
printf("Suprafata %d\n",t->sup); break;
printf("Numarul de locuitori %d\n",t->nl); case 6: m3=0; break;
printf("PIB-ul %.2f\n",t->pib);
9
 default: printf("\a\nAti introdus o comanda }
gresita!\n"); break; return 0;
} pause }
}

Rezultatele obtinute:
Meniu

Modul de lucru

Utilizind coada

Afisarea

10
 Cautarea

Marimea arborelui

Inaltimea arborelui

Eliberarea memoriei

11
 Concluzie
1. Am obtinut deprinderi practice de implementare a unui tip de date abstract (TDA) in
limbajul C si anume a TDA “Arbore binar” utilizind algoritmi iterativi si recursivi.”
2. In urma acestei lucrari de laborator am ajuns la ideia ca e destul de usor de lucrat
cu TDA « Arbore binar »Deasemenea verificarea rezultatelor demonstreaza ca
valoariile primite sunt adevarate ceea ce arata ca programul lucreaza .

Bibliografie:
 TOTUL DESPRE C SI C++ (MANUALUL FUNDAMENTAL DE
PROGRAMARE IN C SI C++)[RO][Kris Jamsa][Lars Kland]
 http://www.scribd.com/doc/41293824/Negrescu-Liviu-Limbajele-C-si-C-
pentru-incepatori-vol-1

12