Ministerul Educaiei 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

Chiinu 2016
0

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

Algoritmi iterativi si algoritmi recursivi.
Scopul lucrarii: Obinerea deprinderilor de implementare practice in limbajul C a tipului de
date abstract (TDA) Arbore binar geniralizat, utiliznd algoritmi iterativi si recursivi.
Sarcina de lucru: De scris trei fiiere n limbajul C pentru implementarea (2 fisiere) si utilizarea
(1 fiier program cu funcia main) a TDA Arbore binar geniralizat :
1. Fiierul antet cu extensia (h) care descrie structura nodului al arborelui binar (conform
variantei din lucrarea de laborator 1) i prototipurile funciilor care asigur operaiunile de
prelucrare a arborelui binar. Pentru lucrare de laborator 4 n acest fiier trebuie de adaugat
descrierea structurilor elementelor cozei i a stivei unde vor fi stocate adresele nodurilor ale
arborelui binar precum i prototipurile funciilor de inserare i eliminare a elimentului pentru
coada i stiva respectiv.
2. Fisier cu extensia (cpp sau c) care conine codurile (implementrile) tuturor func iilor
declarate n fiierul antet.
3. Fiierul utilizatorului - programul cu funcia main () pentru prelucrarea arborelui binar cu
afiarea meniului de optiuni pe ecran, si anume: crearea arborelui binar geniralizat mpreuna cu
introducerea informaiei nodurilor arborelui de la tastatur n rejim interactiv, afiarea informatiei
despre nodurile arborelui pe ecran i a adreselor nodului current, copilului sting i copilului drept
al acestora, cutarea nodului dup un cmp informaional al nodului, determinarea numrului de
noduri n arbore, determinarea nalimei a arborelui, eliberarea memoriei dinamice alocate pentru
arbore, ieire din program.
n lucrare de laborator 4 funciile de prelucrare ale arborelui binar trebuie impementate
folosind algoritm iterativ n 2 versiuni:
a) utiliznd coada - pentru parcurgerea arborelui n largime (parcurgerea arborelui pe niveluri) i
b) utiliznd stiva pentru parcurgerea arborelui n adncime (parcurgerea inordine: rdcin ->
subarbore stng(drept) -> subarbore drept(stng). O excepie face funcia de eliberare a memoriei
dinamice alocate pentru arbore ( trebuie folosit parcurgerea postordine: subarbore stng(drept)
-> subarbore drept(stng) -> rdcin).
n lucrare de laborator 5 funciile de prelucrare ale arborelui binar, trebuie implementate
folosind algoritm recursiv pentru parcurgerea arborelui n adncime: rdcin -> subarbore
stng(drept) -> subarbore drept(stng). i aici o excepie face funcia de eliberare a memoriei
dinamice alocate pentru arbore (trebuie folosit parcurgerea postordine: subarbore stng(drept) ->
subarbore drept(stng) -> rdcin).
n lucrare de laborator 5 funcia de afiare a informaei 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.

Varianta 10: Stat

Noiuni 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>
#include <stdlib.h>
#include <string.h>
#include "struct.h"
#define pause printf("\n\n"); system("pause");
//inserarea elementului in coada
int inq(nod *v){
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=v;
return 1;
}
//stergerea elementului din coada
nod* delq(){
elq *c=first;
nod *v;
if(c == last){
first=last=NULL;

} else {
first=c->next;
}
v=c->adrnod;
free(c);
return v;
}
//inserarea elementului in stiva
int push(nod *v){
els *c;
c=(els*)malloc(sizeof(els));
if(!c) return 0;
c->prev=top;
c->adrnod=v;
top=c;
return 1;
}
//stergerea elementului din stiva
nod* pop(){
els *c=top;
nod *v;
top=c->prev;
v=c->adrnod;
free(c);
return v;
}

//crearea arborelui in coada

int creat_q(){
int f;
nod *c,*p;
first=last=NULL;
printf("Doriti sa creati radacina arborelui (1/0)? :\n ");
scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -1;
printf("\nIntroduceti datele :\n");\
printf("Denumirea : "); scanf("%s",&c>denumire);\
printf("Capitala : "); scanf("%s",&c>capitala);\
printf("Suprafata : "); scanf("%d",&c->sup);\
printf("Numarul de locuitori : ");
scanf("%d",&c->nl);\
printf("PIB-ul : "); scanf("%f",&c>pib);
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)? : \n",p->denumire);
scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -3;
printf("\nIntroduceti datele :\n");\
printf("Denumirea : "); scanf("%s",&c>denumire);\
printf("Capitala : "); scanf("%s",&c>capitala);\
printf("Suprafata : "); scanf("%d",&c->sup);\
printf("Numarul de locuitori : ");
scanf("%d",&c->nl);\
printf("PIB-ul : "); scanf("%f",&c>pib);
p->left=c;
if(!inq(c)) return -2;
} else {
p->left=NULL;
}
printf("De creat copilul drept al nodului %s (1/0)? :
\n",p->denumire);
scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -3;
printf("\nIntroduceti datele :\n");\
printf("Denumirea : "); scanf("%s",&c>denumire);\
printf("Capitala : "); scanf("%s",&c>capitala);\
printf("Suprafata : "); scanf("%d",&c->sup);\
printf("Numarul de locuitori : ");
scanf("%d",&c->nl);\
printf("PIB-ul : "); scanf("%f",&c>pib);
p->right = c;
if(!inq(c)) return -2;
} else {
p->right = NULL;
}
}
return 1;
}

//Afisarea in coada
int show_q(){
nod *p,*c;
first=last=NULL;
if(!root) return 0;
p=root;
if(!inq(p)) return -2;
printf("Lista Statelor\n\n");
while(first){
p=delq();
printf("=====================================
=============\n\n");
printf("Denumire
%s\n",p>denumire);
printf("Capitala
%s\n",p->capitala);
printf("Suprafata
%d\n",p->sup);
printf("Numarul de locuitori
%d\n",p->nl);
printf("PIB-ul
%.2f\n\n",p->pib);
printf("Adresa elementului curent
%p\n",p);
printf("Adresa copilului drept
%p\n",p>right);
printf("Adresa copilului sting
%p\n",p->left);
c=p->left;
if(c){
if(!inq(c)) return -2;
}
c=p->right;
if(c){
if(!inq(c)) return -2;
}
}
return 1;
}
//cautarea in coada
nod* search_q(char *fname){
nod *p,*c;
first=last=NULL;
if(!root) return NULL;
p=root;
if(!inq(p)) return NULL;
while(first){
p=delq();
if(!strcmp(p->denumire,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;
}
//marimea in coada
int size_q(){
int s=0;
nod *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;
}
//eliberarea memoriei in coada
int freemem_q(){
nod *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;
}
//crearea arborelui in stiva
int creat_s(){
nod *p, *c;
int f;
root=NULL;
top=NULL;
printf("Doriti sa creati radacina arborelui (1/0)? :\n ");
fflush(stdin);
scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -1;
printf("\nIntroduceti datele :\n");\
printf("Denumirea : "); scanf("%s",&c>denumire);\
printf("Capitala : "); scanf("%s",&c>capitala);\
printf("Suprafata : "); scanf("%d",&c->sup);\
printf("Numarul de locuitori : ");
scanf("%d",&c->nl);\
printf("PIB-ul : "); scanf("%f",&c>pib);
if(!push(c)) return -5;
root=c;
while(top){
p=pop();
printf("Doriti sa creati copilul drept al nodului %s
(1/0)? :\n ",p->denumire);
fflush(stdin);
scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -3;
printf("\nIntroduceti datele :\n");\
printf("Denumirea : "); scanf("%s",&c>denumire);\
printf("Capitala : "); scanf("%s",&c>capitala);\
printf("Suprafata : "); scanf("%d",&c->sup);\
printf("Numarul de locuitori : ");
scanf("%d",&c->nl);\

printf("PIB-ul : "); scanf("%f",&c>pib);

p->right = c;
if(!push(c)) return -5;
} else {
p->right = NULL;
}
printf("Doriti sa creati copilul sting al nodului %s
(1/0)? : \n",p->denumire);
fflush(stdin);
scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -3;
printf("\nIntroduceti datele :\n");\
printf("Denumirea : "); scanf("%s",&c>denumire);\
printf("Capitala : "); scanf("%s",&c>capitala);\
printf("Suprafata : "); scanf("%d",&c->sup);\
printf("Numarul de locuitori : ");
scanf("%d",&c->nl);\
printf("PIB-ul : "); scanf("%f",&c>pib);
p->left=c;
if(!push(c)) return -5;
} else {
p->left=NULL;
}
}
}
return 1;
}
//afisarea in stiva
int show_s(){
nod *p,*c;
top=NULL;
if(!root) return 0;
p=root;
if(!push(p)) return -5;
printf("Lista Statelor\n\n");
while(top){
p=pop();
printf("=====================================
======\n\n");
printf("Denumire
%s\n",p>denumire);
printf("Capitala
%s\n",p->capitala);
printf("Suprafata
%d\n",p->sup);
printf("Numarul de locuitori
%d\n",p->nl);
printf("PIB-ul
%.2f\n\n",p->pib);
printf("Adresa elementului curent
%p\n",p);
printf("Adresa copilului drept
%p\n",p>right);
printf("Adresa copilului sting
%p\n",p->left);
c=p->right;
if(c!=NULL){
if(!push(c)) return -5;
}
c=p->left;
if(c!=NULL){
if(!push(c)) return -5;
}
}
pause
return 1;
}
//marimea in stiva
int size_s(){

nod *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;
}
//cautarea in stiva
nod* search_s(char *fname){
nod *p,*c;
top=NULL;
if(!root) return NULL;
p=root;
if(!push(p)) return NULL;
while(top){
p=pop();
if(!strcmp(fname,p->denumire)) 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;
}
//eliberarea memoriei in stiva
int freemem_s(){
nod *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;
}
//crearea recursiv
int creat_r(){
nod *p, *c;
int f;
root=NULL;
top=NULL;
printf("Doriti sa creati radacina arborelui (1/0)? :\n ");

fflush(stdin);
scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -1;
printf("\nIntroduceti datele :\n");\
printf("Denumirea : "); scanf("%s",&c>denumire);\
printf("Capitala : "); scanf("%s",&c>capitala);\
printf("Suprafata : "); scanf("%d",&c->sup);\
printf("Numarul de locuitori : ");
scanf("%d",&c->nl);\
printf("PIB-ul : "); scanf("%f",&c>pib);
if(!push(c)) return -5;
root=c;
while(top){
p=pop();
printf("Doriti sa creati copilul drept al nodului %s
(1/0)? :\n ",p->denumire);
fflush(stdin);
scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -3;
printf("\nIntroduceti datele :\n");\
printf("Denumirea : "); scanf("%s",&c>denumire);\
printf("Capitala : "); scanf("%s",&c>capitala);\
printf("Suprafata : "); scanf("%d",&c->sup);\
printf("Numarul de locuitori : ");
scanf("%d",&c->nl);\
printf("PIB-ul : "); scanf("%f",&c>pib);
p->right = c;
if(!push(c)) return -5;
} else {
p->right = NULL;
}
printf("Doriti sa creati copilul sting al nodului %s
(1/0)? : \n",p->denumire);
fflush(stdin);
scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -3;
printf("\nIntroduceti datele :\n");\
printf("Denumirea : "); scanf("%s",&c>denumire);\
printf("Capitala : "); scanf("%s",&c>capitala);\
printf("Suprafata : "); scanf("%d",&c->sup);\
printf("Numarul de locuitori : ");
scanf("%d",&c->nl);\
printf("PIB-ul : "); scanf("%f",&c>pib);
p->left=c;
if(!push(c)) return -5;
} else {
p->left=NULL;
}
}
}
return 1;
}
//afisarea recursiv
void show_r(nod *c){
if(!c){
return;
}

printf("=====================================
=\n\n");
printf("Denumirea
%s\n",c->denumire);
printf("Capitala
%s\n",c->capitala);
printf("Suprafata
%d\n",c->sup);
printf("Numarul de locuitori
%d\n",c->nl);
printf("PIB-ul
%.2f\n\n",c->pib);
printf("Adresa elementului curent %p\n",c);
printf("Adresa copilului drept
%p\n",c->right);
printf("Adresa copilului sting
%p\n",c->left);
show_r(c->left);
show_r(c->right);
}
//eliberarea memoriei recursiv
void freemem_r(nod *c){
if(!c) return;
freemem_r(c->left);
freemem_r(c->right);
free(c);
}

t=search_r(c->left,fname);
if (t) return t;
t=search_r(c->right,fname);
if (t) return t;
return NULL;
}
//marimea recursiv
int size_r(nod *c){
static int n=0;
if(!c) return n;
n++;
size_r(c->left);
size_r(c->right);
return n;
}
//inaltimea arborelui
int height_r(nod *c){
int l,r;
if(!c) return -1;
l=height_r(c->left);
r=height_r(c->right);
if(l>r)return(l+1);
else{return(r+1);
}
}

//cautarea recursiv
nod* search_r(nod* c, char *fname){
nod* t=NULL;
if(!c) return NULL;
if (!strcmp(c->denumire,fname)) return c;

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

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

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);
t=search_q(fname);
if(t){

case 3:
printf("Arborele are noduri ");
find_error(size_s()); break;
case 4:

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

printf("Inaltimea arborelui este

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

default: printf("\a\nAti introdus o comanda

gresita!\n"); break;
} pause
}

}
return 0;
}

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-Cpentru-incepatori-vol-1

12