Sunteți pe pagina 1din 24

Ministerul Educaiei al Republicii Moldova

Universitatea Tehnic a Moldovei

Catedra Informatica Aplicat

RAPORT
Lucrarea de laborator nr.4-5
Tip abstract de date. Arbore binar

A efectuat:
st. gr. SI-141

E. Cucu

A verificat:
dr., conf.univ., catedra IA

M. Kulev

Chiinu 2015

Lucrarri de laborator nr.4-5


Tema: Implementarea tipului de date abstract Arbore binar in C
Scopul lucrrii: obinerea deprinderilor practice de implementare a unui tip de date
abstract (TDA) in limbajul C si anume a TDA Arbore binar
Condiia problemei (sarcina de lucru) [1]: De scris trei fiiere in limbajul C
pentru implementarea (2 fiiere) si utilizarea (1 fiier program cu funcia Main )
a TDA Lista simplu nlnuit:
1. Fiierul antet cu extensia .h care descrie structura de date a elementului
tabloului (conform variantei din lucrare precedenta) i prototipurile funciilor
care asigur operaiunile de prelucrare a tabloului de structuri.
2. Fiier cu extensia .cpp (sau .c) care conine codurile (implementrile)
tuturor funciilor declarate n fiierul antet.
3. Fiierul utilizatorului - programul cu funcia main () pentru prelucrarea
tabloului de structuri cu afiarea meniului de opiuni pe ecran, si anume: alocarea
memoriei dinamice pentru tablou, introducerea informaiei despre elementele
tabloului de la tastatura, afiarea informaiei despre elementele tabloului pe ecran,
cutarea elementului tabloului dup unui cmp al structurii, modificarea
cmpurilor elementului tabloului, interschimbarea a 2 elemente tabloului,
sortarea elementelor tabloului dup unui cmp, adugarea unui element nou la
sfritul tabloului, adugarea unui element nou la nceputul tabloului, inserarea
unui element nou in tabloul la poziia indicata, tergerea unui element al tabloului,
scrierea informaiei despre elementele tabloului n fiier, citirea informaiei despre
elementele tabloului din fiier, eliberarea memoriei alocate pentru tablou, ie ire
din program.

Varianta 10: Masini


Mersul lucrrii:
Noiuni principale din teorie i metode folosite:
n informatic, un arbore binar este un arbore n care fiecare nod are cel
mult doi succesori (fii). De obicei, succesorii se numesc nodul stnga i nodul
dreapta. Arborii binari sunt folosii mai ales drept arbori binari de cutare sau i
la structurile de date de tip heap.

Implementare:
typedef struct arb
{
int info;
struct carte *left, *right;
}arb;

Analiza datelor:
Functia main:
Descrierea:Functia principala a programului.
a) date de intrare: nu sunt.
b) date de ieire: nu sunt.
c) date intermediare:
command variabil simpl de tip ntreg, opiunea aleas de utilizator;
m,m1,m2,m3,f - variabil simpl de tip ntreg, determin dac funcia s-a
efectuat cu succes;
t - variabil locala de tip pointer la nod;
fname-variabila de tip pointer la char,denumirea fisierului pentru introducere

int enq(nod* inf):


Descrierea:Functia pentru inserarea unui element in coada.
a) parametri primii:
inf pointer de tip nod, adresa nodului care se introduce n coad;
b) date returnabile: functia returnaza 1 daca s-a locat memorie -1 invers;
c) date locale:
c pointer de tip coad, memoria elementului adugat;
nod* deq(void):
Descriere:Functia pentru eliminarea unui element din coada astfel obtinindui
adresa lui.
a) parametri primii: nu sunt;
b) date returnabile:
inf pointer de tip nod (arbore), elementul ters;
c) date locale:
c pointer de tip coad, adresa n care se stocheaz elementul ce urmeaz s
fie ters;
d)
int push(nod* inf):
Descriere:Functia pentru inserarea unui element in stiva.
a) parametri primii:
inf pointer de tip nod, adresa nodului care se introduce n stiva;
b) date returnabile: functia returnaza 1 daca s-a locat memorie -1 invers;date
locale:
c pointer de tip stiv, memoria elementului adugat;

nod *pop(void):
Descriere:Functia pentru eliminarea unui element din stiva astfel obtinindui adresa
lui.
a) parametri primii: nu sunt;
b) date returnabile:
inf pointer de tip nod, elementul ters;
c) date locale:
c pointer de tip stiv, adresa n care se stocheaz elementul ce urmeaz s
fie ters;
int show_q(void):
Descriere:Functri pentru afisarea liste de elemente cu ajutorul cozii in largime
a) parametri primii: nu sunt;
b) date returnabile:
functia returneaza 1 daca elementele au fost gasite,0 daca lista este vida,
c) p,c pointer de tip nod, variabile pentru prelucrarea listei;
int show_s(void):
Descriere:Functri pentru afisarea liste de elemente cu ajutorul stivei in adincime
a) parametri primii: nu sunt;
b) date returnabile:
functia returneaza 1 daca elementele au fost gasite,0 daca lista este vida,
c) p,c pointer de tip nod, variabile pentru prelucrarea listei;
int size_q(void):
Descriere:Functia pentru afisarea la ecran la marimii arborelui cu ajutorul cozii
a) parametri primii: nu sunt;
b) date returnabile:
n variabil simpl de tip ntreg, mrimea arborelui;
c) date intermediare:
c,p pointeri de tip nod, variabile pentru prelucrarea listei;
int size_s(void):
Descriere:Functia pentru afisarea la ecran la marimii arborelui cu ajutorul stivei
a) parametri primii: nu sunt;
b) date returnabile:
n variabil simpl de tip ntreg, mrimea arborelui;
c) date intermediare:
c,p pointeri de tip nod, variabile pentru prelucrarea listei;

int create_q(void):
Descriere:Functia pentru crearea arborelui cu ajutorul cozii.
a) parametri primii: nu sunt;
b) date returnabile: returneaza 1 daca elementul a fost creat cu succes,0 invers;
c) date intermediare:
f variabil simpl de tip ntreg, rspunsul utilizatorului.
c,p pointeri de tip carte(arbore), variabile pentru prelucrarea listei;
int create_s(void):
Descriere:Functia pentru crearea arborelui cu ajutorul stivei.
a) parametri primii: nu sunt;
b) date returnabile: returneaza 1 daca elementul a fost creat cu succes,0 invers;
c) date intermediare:
f variabil simpl de tip ntreg, rspunsul utilizatorului.
c,p pointeri de tip carte(arbore), variabile pentru prelucrarea listei;
nod* search_q(char* fname):
Descriere:Functia pentru cautarea unui element dupa un cimp al structurii cu
ajutorul cozii.
a) parametri primii:fname variabila de tip ponter la char,denumirea
elementrului pentru cautare;
b) date returnabile:
p - pointer de tip nod,adresa elementului gsit;
c) date locale:
p,c pointer de tip nod, variabile pentru prelucrarea listei;
nod* search_s(char* fname):
Descriere:Functia pentru cautarea unui element dupa un cimp al structurii cu
ajutorul stivei.
a) parametri primii:fname variabila de tip ponter la char,denumirea
elementrului pentru cautare;
b) date returnabile:
p - pointer de tip nod,adresa elementului gsit;
c) date locale:
p,c pointer de tip nod, variabile pentru prelucrarea listei.
int freemem(void):
a) parametri primii: nu sunt;
b) date returnabile: nu sunt.
c) date intermediare:
l variabil simpl de tip ntreg, verific dac elementul s-a introdus n
stiv;
c,p pointeri de tip carte(arbore), variabile pentru prelucrarea listei;

nod* createRSD(void):
Descriere:Functia pentru crearea arborelui recursiv RSD.
a) parametri primii: nu sunt;
b) date returnabile:
c - pointer de tip nod,adresa rdcinii;
c) date locale:
f variabil simpl de tip ntreg, rspunsul utilizatorului;
funciile void show(carte *c):
Descriere:Functia pentru afisarea elemntelor cu ajutorul
recursei(RSD,RDS,SRD,DSR,SDR,DSR)
a) parametri primii:
c-pointer de tip carte(arbore), adresa elementului care va fi afiat;
b) date returnabile: nu sunt;
c) date locale: nu sunt;
nod* searchRSD(nod *c,):
Descriere:Functia pentru cautarea unui elementru cu ajutorul recursiei.
a) parametri primii:
c-pointer de tip nod, adresa rdcinii;
date returnabile:
c-pointer de tip carte, adresa elementului gsit;
b) date locale: nu sunt;
int sizeRSD(carte *c):
Descriere:Functia pemtri afisareala ecran a mariii arborelui cu ajutorul recuriei.
a) parametri primii:
c-pointer de tip nod, adresa rdcinii;
b) date returnabile: mrimea arborelui;
c) date locale: nu sunt;

int highRSD(carte *c):


Descriere:Functia pentru afsarea la ecran a naltimii arborelui cu ajutorul recursiei.
a) parametri primii:
c-pointer de tip nodmadresa rdcinii;
b) date returnabile:
r,l variabile simple de tip ntreg, nlimea arborelui;
c) date locale: nu sunt;
nod* freememSRD(carte *c):
a) parametri primii:
c-pointer de tip carte(arbore), adresa rdcinii;
6

b) date returnabile: nu sunt;


c) date locale: nu sunt;
Codul (textul) programului in limbajul C:
Fiierul Header.h:
/*********** START Arbore ************/
typedef struct nod{
char nr[40];
char marca[40];
char model[40];
char origine[40];
int anu;
float pret;
struct nod *left;
struct nod *right;
}nod;
nod *root = NULL;
/*********** END Arbore ************/
/*********** START Coada ************/
typedef struct elq{
nod *adrnod;
struct elq *next;
}elq;
elq *first = NULL;
elq *last = NULL;
/*********** END Coada ************/
/*********** START Stiva ************/
typedef struct els{
nod *adrnod;
struct els *prev;
}els;
els *top = NULL;
/*********** END Stiva ************/
/*********** Prototipuri ************/
void find_error(int ord);
int enq(nod *inf);
7

nod* deq();
int push(nod *inf);
nod* pop();
int creat_q();
int creat_s();
nod* creat_rsd();
int show_q();
int show_s();
void show_rsd(nod *c);
void show_rds(nod *c);
void show_srd(nod *c);
void show_drs(nod *c);
void show_sdr(nod *c);
void show_dsr(nod *c);
nod* search_q(char *fname);
nod* search_s(char *fname);
nod* search_rsd(nod* c, char *fname);
int size_q();
int size_s();
int size_rsd(nod *c);
int read_file(char *fname);
int write_file(char *fname);
void print(nod *c,int k=0);
void freemem_rsd(nod *c);
int freemem_q();
int freemem_s();
int height_rsd(nod *c);
Fiierul Funct.CPP:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "struct.h"
#define print_scan printf("\nIntroduceti datele :\n");\
printf("Nr.ordine : "); scanf("%s",&c->nr);\
printf("Marca : "); scanf("%s",&c->marca);\
printf("Model : "); scanf("%s",&c->model);\
printf("Originea : "); scanf("%s",&c->origine);\
printf("Anu : "); scanf("%d",&c->anu);\
printf("Pret($) : "); scanf("%f",&c->pret);
#define pause printf("\n\n"); system("pause");
void find_error(int ord){
switch(ord){
case -6:
printf("\a\n>> Eroare la crearea fisierului! <<\n");
8

break;
case -5:
printf("\a\n>> Eroare la adaugarea nodului in stiva! <<\n");
break;
case -4:
printf("\a\n>> Eroare la deschiderea fisierului! <<\n");
system("pause"); exit(1); break;
case -3:
printf("\a\n>> Eroare la alocarea memoriei pentru fecior! <<\n");
break;
case -2:
printf("\a\n>> Eroare la adaugarea nodului in coada! <<\n");
break;
case -1:
printf("\a\n>> Eroare la alocarea memoriei pentru radacina! <<\n");
break;
case 0:
printf("\a\n>> Eroare ! <<\n"); break;
case 1:
printf("\aOperatia a avut loc cu succes!\n"); break;
default:
printf("<< %d >>\n",ord); break;
}
}
int enq(nod *inf){
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=inf;
return 1;
}
nod* deq(){
elq *c=first;
nod *inf;
if(c == last){
first=last=NULL;
9

} else {
first=c->next;
}
inf=c->adrnod;
free(c);
return inf;
}
int push(nod *inf){
els *c;
c=(els*)malloc(sizeof(els));
if(!c) return 0;
c->prev=top;
c->adrnod=inf;
top=c;
return 1;
}
nod* pop(){
els *c=top;
nod *inf;
top=c->prev;
inf=c->adrnod;
free(c);
return inf;
}
int creat_q(){
int f;
nod *c,*p;
first=last=NULL;
printf("De creat radacina arborelui (1/0)? : ");
scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -1;
print_scan
if(!enq(c)) return -2;
root = c;
}else {
root = NULL;
}
while(first){
p = deq();
printf("De creat copilul sting al nodului %s (1/0)? : ",p->marca);
10

scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -3;
print_scan
p->left=c;
if(!enq(c)) return -2;
} else {
p->left=NULL;
}
printf("De creat copilul drept al nodului %s (1/0)? : ",p->marca);
scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -3;
print_scan
p->right = c;
if(!enq(c)) return -2;
} else {
p->right = NULL;
}
}
return 1;
}
int show_q(){
nod *p,*c;
first=last=NULL;
if(!root) return 0;
p=root;
if(!enq(p)) return -2;
printf("Lista Masinilor\n\n");
while(first){
p=deq();
printf("***************************************\n\n");
printf("Nr.ordine:
%s\n",p->nr);
printf("Marca
%s\n",p->marca);
printf("Model
%s\n",p->model);
printf("Originea
%s\n",p->origine);
printf("Anul
%d\n",p->anu);
printf("Pret($)
%.2f\n\n",p->pret);
c=p->left;
if(c){
if(!enq(c)) return -2;
}
11

c=p->right;
if(c){
if(!enq(c)) return -2;
}
}
return 1;
}
nod* search_q(char *fname){
nod *p,*c;
first=last=NULL;
if(!root) return NULL;
p=root;
if(!enq(p)) return NULL;
while(first){
p=deq();
if(!strcmp(p->marca,fname)) return p;
c=p->left;
if(c){
if(!enq(c)) return NULL;
}
c=p->right;
if(c){
if(!enq(c)) return NULL;
}
}
return NULL;
}
int size_q(){
int s=0;
nod *p,*c;
first=last=NULL;
if(!root) return 0;
p=root;
if(!enq(p)) return -2;
while(first){
p=deq();
s++;
c=p->left;
if(c){
if(!enq(c)) return -2;
}
c=p->right;
if(c){
if(!enq(c)) return -2;
12

}
}
return s;
}
int freemem_q(){
nod *p,*c;
first=last=NULL;
if(!root) return 0;
p=root;
if(!enq(p)) return -2;
while(first){
p=deq();
c=p->left;
if(c){
if(!enq(c)) return -2;
}
c=p->right;
if(c){
if(!enq(c)) return -2;
}
free(p);
}
return 1;
}
int creat_s(){
nod *p, *c;
int f;
root=NULL;
top=NULL;
printf("De creat radacina arborelui (1/0)? : ");
fflush(stdin);
scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -1;
print_scan
if(!push(c)) return -5;
root=c;
while(top){
p=pop();
printf("De creat copilul drept al nodului %s (1/0)? : ",p->marca);
fflush(stdin);
scanf("%d",&f);
if(f){
13

c=(nod*)malloc(sizeof(nod));
if(!c) return -3;
print_scan
p->right = c;
if(!push(c)) return -5;
} else {
p->right = NULL;
}
printf("De creat copilul sting al nodului %s (1/0)? : ",p->marca);
fflush(stdin);
scanf("%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -3;
print_scan
p->left=c;
if(!push(c)) return -5;
} else {
p->left=NULL;
}
}
}
return 1;
}
int show_s(){
nod *p,*c;
top=NULL;
if(!root) return 0;
p=root;
if(!push(p)) return -5;
printf("Lista Masinilor\n\n");
while(top){
p=pop();
printf("***************************************\n\n");
printf("Nr.ordine:
%s\n",p->nr);
printf("Marca
%s\n",p->marca);
printf("Model
%s\n",p->model);
printf("Originea
%s\n",p->origine);
printf("Anul
%d\n",p->anu);
printf("Pret($)
%.2f\n\n",p->pret);
c=p->right;
if(c!=NULL){
if(!push(c)) return -5;
}
14

c=p->left;
if(c!=NULL){
if(!push(c)) return -5;
}
}
pause
return 1;
}
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;
}
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->marca)) return p;
c=p->right;
if(c!=NULL){
if(!push(c)) return NULL;
}
c=p->left;
if(c!=NULL){
15

if(!push(c)) return NULL;


}
}
return NULL;
}
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;
}
int read_file(char *fname){
int f;
nod *c,*p;
FILE *demo=fopen(fname,"rt");
if(!demo) return -4;
first=last=NULL;
c=(nod*)malloc(sizeof(nod));
if(!c) return -1;
fscanf(demo,"%s%s%s%s%d%f",&c->nr,&c->marca,&c->model,&c>origine,&c->anu,&c->pret);
if(!enq(c)) return -2;
root = c;
while(first){
p = deq();
fscanf(demo,"%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -3;
16

fscanf(demo,"%s%s%s%s%d%f",&c->nr,&c->marca,&c->model,&c>origine,&c->anu,&c->pret);
p->left=c;
if(!enq(c)) return -2;
} else {
p->left=NULL;
}
fscanf(demo,"%d",&f);
if(f){
c=(nod*)malloc(sizeof(nod));
if(!c) return -3;
fscanf(demo,"%s%s%s%s%d%f",&c->nr,&c->marca,&c->model,&c>origine,&c->anu,&c->pret);
p->right = c;
if(!enq(c)) return -2;
} else {
p->right = NULL;
}
}
return 1;
}
int write_file(char *fname){
nod *p,*c;
FILE *demo=fopen(fname,"w");
first=last=NULL;
if(!root) return 0;
p=root;
fprintf(demo,"%s %s %s %s %d %.2f",p->nr,p->marca,p->model,p>origine,p->anu,p->pret);
if(!enq(p)) return -2;
while(first){
p=deq();
c=p->left;
if(c){
if(!enq(c)) return -2;
fprintf(demo,"\n1\n%s %s %s %s %d %.2f",c->nr,c->marca,c>model,c->origine,c->anu,c->pret);
} else {
fprintf(demo,"\n0");
}
c=p->right;
if(c){
if(!enq(c)) return -2;
17

fprintf(demo,"\n1\n%s %s %s %s %d %.2f",c->nr,c->marca,c>model,c->origine,c->anu,c->pret);
} else {
fprintf(demo,"\n0");
}
}
fclose(demo);
return 1;
}
nod* creat_rsd(){
nod *c;
int f;
c=(nod*)malloc(sizeof(*c));
if(!c) return NULL;
print_scan
printf("De creat copilul sting al nodului %s (1/0)? : ",c->marca);
fflush(stdin);
scanf("%d",&f);
if(f){
c->left=creat_rsd();
} else {
c->left=NULL;
}
printf("De creat copilul drept al nodului %s (1/0)? : ",c->marca);
fflush(stdin);
scanf("%d",&f);
if(f){
c->right=creat_rsd();
} else {
c->right=NULL;
}
return c;
}
void show_rsd(nod *c){
if(!c){
return;
}
printf("***************************************\n\n");
printf("Nr.ordine:
%s\n",c->nr);
printf("Marca
%s\n",c->marca);
printf("Model
%s\n",c->model);
printf("Origine
%s\n",c->origine);
printf("Anul
%d\n",c->anu);
18

printf("Model
%.2f\n\n",c->pret);
show_rsd(c->left);
show_rsd(c->right);
}
void show_rds(nod *c){
if(!c){
return;
}
printf("***************************************\n\n");
printf("Nr.ordine:
%s\n",c->nr);
printf("Marca
%s\n",c->marca);
printf("Model
%s\n",c->model);
printf("Origine
%s\n",c->origine);
printf("Anul
%d\n",c->anu);
printf("Model
%.2f\n\n",c->pret);
show_rds(c->right);
show_rds(c->left);
}
void show_srd(nod *c){
if(!c){
return;
}
show_srd(c->left);
printf("***************************************\n\n");
printf("Nr.ordine:
%s\n",c->nr);
printf("Marca
%s\n",c->marca);
printf("Model
%s\n",c->model);
printf("Origine
%s\n",c->origine);
printf("Anul
%d\n",c->anu);
printf("Model
%.2f\n\n",c->pret);
show_srd(c->right);
}
void show_drs(nod *c){
if(!c){
return;
}
show_drs(c->right);
printf("***************************************\n\n");
printf("Nr.ordine:
%s\n",c->nr);
printf("Marca
%s\n",c->marca);
printf("Model
%s\n",c->model);
printf("Origine
%s\n",c->origine);
printf("Anul
%d\n",c->anu);
printf("Model
%.2f\n\n",c->pret);
show_drs(c->left);
19

}
void show_sdr(nod *c){
if(!c){
return;
}
show_sdr(c->left);
show_sdr(c->right);
printf("***************************************\n\n");
printf("Nr.ordine:
%s\n",c->nr);
printf("Marca
%s\n",c->marca);
printf("Model
%s\n",c->model);
printf("Origine
%s\n",c->origine);
printf("Anul
%d\n",c->anu);
printf("Model
%.2f\n\n",c->pret);
}
void show_dsr(nod *c){
if(!c){
return;
}
show_dsr(c->right);
show_dsr(c->left);
printf("***************************************\n\n");
printf("Nr.ordine:
%s\n",c->nr);
printf("Marca
%s\n",c->marca);
printf("Model
%s\n",c->model);
printf("Origine
%s\n",c->origine);
printf("Anul
%d\n",c->anu);
printf("Model
%.2f\n\n",c->pret);
}

void print(nod *c,int k){


int i;
if(c){
print(c->right,k+3);
for(i=0;i<k;i++){
printf(" ");
}
printf("%s\n\n",c->marca);
print(c->left,k+3);
}
}
20

void freemem_rsd(nod *c){


if(!c) return;
freemem_rsd(c->left);
freemem_rsd(c->right);
free(c);
}
nod* search_rsd(nod* c, char *fname){
nod* t=NULL;
if(!c) return NULL;
if (!strcmp(c->marca,fname)) return c;
t=search_rsd(c->left,fname);
if (t) return t;
t=search_rsd(c->right,fname);
if (t) return t;
return NULL;
}
int size_rsd(nod *c){
static int n=0;
if(!c) return n;
n++;
size_rsd(c->left);
size_rsd(c->right);
return n;
}
int height_rsd(nod *c){
int l=0,r=0;
if(!c) return -1;
l=1+height_rsd(c->left);
r=1+height_rsd(c->right);
if(l>r) return l;
else return r;
}

21

Screen Shot-uri:
Meniul principal:

Meniul pentru coada

Meniul pentru stiva:

Meniu pentru recursie:

22

Analiza rezultatelor si concluzii:


n urma efecturii acestui laborator, am elaborat un program de prelucrare a
unui arbore binar i am nsuit modul de modul de repartizare a codului n fiiere,
ceea ce permite ca codul s fie mai uor de citit i redactat. Am elaborat un meniu
prin care utilizatorul poate comunica cu programul elaborat i am implementat cele
mai utile funcii de prelucrare a arborelui binar.
Bibliografie:
1. Conspectul prelegerilor cursului Programarea Calculatoarelor. Lector dr.,
conf. univ. M.Kulev. Chiinu: UTM, 2014.
2. http://www.cplusplus.com/reference/cstdio/fwrite/?kw=fwrite
(03,12,2015)
3. 1. http://problemegratis.blogspot.com/2013/03/vectori-caracterestring.html (03,12,2015)

23