Exemplu SDA lab10 si lab11

Tema: Implementarea tipului de date abstract “Arbore binar oarecare” in limbajul C. Algoritmi
iterativi si algoritmi recursivi.

Noţiuni de bază

Operatiile de prelucrare ale arborelui binar oarecare pot fi implementate utilizind algoritmi
iterativi sau algoritmi recursivi.

Algoritmi iterativi sunt utilizate pentru parcurgerea nodurilor arborelui “în lațime” (pe niveluri)
folosind structura de tip Coada sau pentru parcurgerea nodurilor arborelui “în adincime” (în
preordine) folosind structura de tip Stiva (lucrarea de laborator nr. 10).

Algoritmi recursivi sunt utilizate pentru parcurgerea nodurilor arborelui prin 6 modalități în
preordine (în adîncime) (2 parcurgeri), în inordine (2 parcurgeri) și în postordine (2 parcurgeri).

Structura de tip Stiva. Aceasta structura de date este un caz particular de lista care
functioneaza pe principiul LIFO (last in – first out, ultimul intrat este primul servit, puteti sa va
ganditi la o stiva de materiale pentru care un nou material se va adauga intotdeauna deasupra si
se va extrage tot de deasupra). Specific acestei structuri de date este faptul ca prelucrarile se fac
intotdeauna la elementul de la acelasi capat, element pe care il vom numi vîrf.
Functia push( ) , creaza stiva cand aceasta este vida sau adauga un nou element in caz
contrar.
Functia pop( ), elimina elementul din vîrful stivei.
Structura de date de tip Coada. Aceasta structura de date este un caz particular de lista care
functioneaza pe principiul FIFO (first in – first out, primul intrat este primul servit). Specific
acestei structuri de date este faptul ca adaugarea se va face intotdeauna la ultim in timp ce
prelucrarea (stergerea) se va face la celalat capat. Pentru a prelucra o coada vor fi necesari doi
pointeri: unul il vom numi varful cozii (primul nod creat) in timp ce la capatul opus ne vom
referi la ultimul element.
Functia pune( ) , creaza coada cand aceasta este vida sau adauga un nou element la sfarsit in
caz contrar.
Functia scoate( ), elimina elementul din varful cozii.

Recursivitate. O noţiune este definită recursiv dacă în cadrul definiţiei intervine însăşi noţiunea
care se defineşte .
Reguli fundamentale pentru ca recursia să fie definită corect:

1. Trebuie să existe şi cazuri elementare, care se pot rezolva direct.

2. Pentru cazurile care nu se rezolvă direct, recursia trebuie să progreseze către un caz elementar.

Descrierea variabilelor
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
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: 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: 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
Functia: show_SRD(nod *c), show_SDR(nod *c), show_RDS(nod *c), show_DRS(nod *c),
show_DSR(nod *c)
c-variabila locala de tip structura, adresa nodului copil

Codul programului pentru ambele lucrari de laborator (lab10 si lab11)

Fisierul “struct.h”
// Nodul arborelui conține info despre Casa de scimb valutar
// Structura nodului Arborelui binar
typedef struct nod{
char denum[40]; // Denumirea
char prop[40]; // Proprietarul
char adresa[50]; // Adresa
char oral[30]; // Orarul
char tel[30]; // Telefonul
struct nod *left;
struct nod *right;
} nod;

nod *root;

// Structura elementului Cozei

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

elq *first;
elq *last;

// Structura elementului Stivei

typedef struct els{
nod *adrnod;
struct els *prev;
}els;

els *top;

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> if(!c) return 0;
#include <conio.h> if(!first){
#include <stdlib.h> first = c;
#include <string.h> } else {
#include "struct.h" last->next=c;
#define pause printf("\n\n"); system("pause"); }
last=c;
c->next=NULL;
c->adrnod=v;
int inq(nod *v){ return 1;
elq *c; }
c=(elq*)malloc(sizeof(elq));
 printf("Proprietarul: "); scanf("%s",&c-
nod* delq(){ >prop);\
elq *c=first; printf("Adresa: "); scanf("%s",&c->adresa);\
nod *v; printf("Oralul: "); scanf("%s",&c-
if(c == last){ >oral);\
first=last=NULL; printf("Telefonul: "); scanf("%s",&c-
} else { >tel);
first=c->next; p->left=c;
} if(!inq(c)) return -2;
v=c->adrnod; } else {
free(c); p->left=NULL;
return v; }
} printf("\nDoriti sa creati copilul drept al nodului %s
(1/0)? : \n",p->denum);
scanf("%d",&f);
int push(nod *v){ if(f){
els *c; c=(nod*)malloc(sizeof(nod));
c=(els*)malloc(sizeof(els)); if(!c) return -3;
if(!c) return 0; printf("\nIntroduceti datele :\n");\
c->prev=top; printf("Denumirea: "); scanf("%s",&c-
c->adrnod=v; >denum);\
top=c; printf("Proprietarul: "); scanf("%s",&c-
return 1; >prop);\
} printf("Adresa: "); scanf("%s",&c->adresa);\
printf("Oralul: "); scanf("%s",&c-
>oral);\
nod* pop(){ printf("Telefonul: "); scanf("%s",&c-
els *c=top; >tel);
nod *v; p->right = c;
top=c->prev; if(!inq(c)) return -2;
v=c->adrnod; } else {
free(c); p->right = NULL;
return v; }
} }
return 1;
}
int creat_q(){
int f;
nod *c,*p; int show_q(){
first=last=NULL; nod *p,*c;
printf("Doriti sa creati radacina arborelui (1/0)? :\n "); first=last=NULL;
scanf("%d",&f); if(!root) return 0;
if(f){ p=root;
c=(nod*)malloc(sizeof(nod)); if(!inq(p)) return -2;
if(!c) return -1; printf("Informatii despre case de schimb:\n\n");
printf("\nIntroduceti datele :\n");\ while(first){
printf("Denumirea: "); scanf("%s",&c- p=delq();
>denum);\
printf("Proprietarul: "); scanf("%s",&c- printf("Denumirea: %s\n",p->denum);
>prop);\ printf("Proprietarul: %s\n",p->prop);
printf("Adresa: "); scanf("%s",&c->adresa);\ printf("Adresa: %s\n",p->adresa);
printf("Oralul: "); scanf("%s",&c- printf("Oralul: %s\n",p->oral);
>oral);\ printf("Telefonul: %s\n",p->tel);
printf("Telefonul: "); scanf("%s",&c- printf("Adresa elementului curent: %p\n",p);
>tel); printf("Adresa copilului drept: %p\n",p->right);
if(!inq(c)) return -2; printf("Adresa copilului sting: %p\n",p->left);
root = c; c=p->left;
}else { if(c){
root = NULL; if(!inq(c)) return -2;
} }
while(first){ c=p->right;
p = delq(); if(c){
printf("\nDoriti sa creati copilul sting al nodului if(!inq(c)) return -2;
%s (1/0)? : \n",p->denum); }
scanf("%d",&f); }
if(f){ return 1;
c=(nod*)malloc(sizeof(nod)); }
if(!c) return -3;
printf("\nIntroduceti datele :\n");\
printf("Denumirea: "); scanf("%s",&c- nod* search_q(char *fname){
>denum);\ nod *p,*c;
first=last=NULL;
 if(!root) return NULL; if(f){
p=root; c=(nod*)malloc(sizeof(nod));
if(!inq(p)) return NULL; if(!c) return -1;
while(first){ printf("\nIntroduceti datele :\n");\
p=delq(); printf("Denumirea: "); scanf("%s",&c-
if(!strcmp(p->denum,fname)) return p; >denum);\
c=p->left; printf("Proprietarul: "); scanf("%s",&c-
if(c){ >prop);\
if(!inq(c)) return NULL; printf("Adresa: "); scanf("%s",&c->adresa);\
} printf("Oralul: "); scanf("%s",&c-
c=p->right; >oral);\
if(c){ printf("Telefonul: "); scanf("%s",&c-
if(!inq(c)) return NULL; >tel);
} if(!push(c)) return -5;
} root=c;
return NULL; while(top){
} p=pop();
printf("\nDoriti sa creati copilul drept al nodului %s
(1/0)? :\n ",p->denum);
int size_q(){ fflush(stdin);
int s=0; 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){ >denum);\
p=delq(); printf("Proprietarul: "); scanf("%s",&c-
s++; >prop);\
c=p->left; printf("Adresa: "); scanf("%s",&c->adresa);\
if(c){ printf("Oralul: "); scanf("%s",&c-
if(!inq(c)) return -2; >oral);\
} printf("Telefonul: "); scanf("%s",&c-
c=p->right; >tel);
if(c){ p->right = c;
if(!inq(c)) return -2; if(!push(c)) return -5;
} } else {
} p->right = NULL;
return s; }
} printf("\nDoriti sa creati copilul sting al nodului
%s (1/0)? : \n",p->denum);
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){ >denum);\
p=delq(); printf("Proprietarul: "); scanf("%s",&c-
c=p->left; >prop);\
if(c){ printf("Adresa: "); scanf("%s",&c->adresa);\
if(!inq(c)) return -2; printf("Oralul: "); scanf("%s",&c-
} >oral);\
c=p->right; printf("Telefonul: "); scanf("%s",&c-
if(c){ >tel);
if(!inq(c)) return -2; p->left=c;
} if(!push(c)) return -5;
free(p); } else {
} p->left=NULL;
return 1; }
} }
}
return 1;
int creat_s(){ }
nod *p, *c;
int f;
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(!push(p)) return -5; nod *p,*c;
printf("Informatii despre case de schimb:\n\n"); top=NULL;
while(top){ if(!root) return 0;
p=pop(); p=root;
if(!push(p)) return -5;
printf("Denumirea: %s\n",p->denum); while(top){
printf("Proprietarul: %s\n",p->prop); p=pop();
printf("Adresa: %s\n",p->adresa); c=p->right;
printf("Oralul: %s\n",p->oral); if(c!=NULL){
printf("Telefonul: %s\n",p->tel); if(!push(c)) return -5;
printf("Adresa elementului curent: %p\n",p); }
printf("Adresa copilului drept: %p\n",p->right); c=p->left;
printf("Adresa copilului sting: %p\n",p->left); if(c!=NULL){
c=p->right; if(!push(c)) return -5;
if(c!=NULL){ }
if(!push(c)) return -5; free(p);
} }
c=p->left; return 1;
if(c!=NULL){ }
if(!push(c)) return -5;
} int creat_r(){
} nod *p, *c;
pause int f;
return 1; root=NULL;
} top=NULL;
printf("Doriti sa creati radacina arborelui (1/0)? :\n ");
fflush(stdin);
int size_s(){ scanf("%d",&f);
nod *p,*c; if(f){
int s=0; c=(nod*)malloc(sizeof(nod));
top=NULL; if(!c) return -1;
if(!root) return 0; printf("\nIntroduceti datele :\n");\
p=root; printf("Denumirea: "); scanf("%s",&c-
if(!push(p)) return -5; >denum);\
while(top){ printf("Proprietarul: "); scanf("%s",&c-
p=pop(); s++; >prop);\
c=p->right; printf("Adresa: "); scanf("%s",&c->adresa);\
if(c!=NULL){ printf("Oralul: "); scanf("%s",&c-
if(!push(c)) return -5; >oral);\
} printf("Telefonul: "); scanf("%s",&c-
c=p->left; >tel);
if(c!=NULL){ if(!push(c)) return -5;
if(!push(c)) return -5; root=c;
} while(top){
} p=pop();
return s; printf("\nDoriti sa creati copilul drept al nodului %s
} (1/0)? :\n ",p->denum);
fflush(stdin);
scanf("%d",&f);
nod* search_s(char *fname){ if(f){
nod *p,*c; c=(nod*)malloc(sizeof(nod));
top=NULL; if(!c) return -3;
if(!root) return NULL; printf("\nIntroduceti datele :\n");\
p=root; printf("Denumirea: "); scanf("%s",&c-
if(!push(p)) return NULL; >denum);\
while(top){ printf("Proprietarul: "); scanf("%s",&c-
p=pop(); >prop);\
if(!strcmp(fname,p->denum)) return p; printf("Adresa: "); scanf("%s",&c->adresa);\
c=p->right; printf("Oralul: "); scanf("%s",&c-
if(c!=NULL){ >oral);\
if(!push(c)) return NULL; printf("Telefonul: "); scanf("%s",&c-
} >tel);
c=p->left; p->right = c;
if(c!=NULL){ if(!push(c)) return -5;
if(!push(c)) return NULL; } else {
} p->right = NULL;
} }
return NULL; printf("\nDoriti sa creati copilul sting al nodului
} %s (1/0)? : \n",p->denum);
fflush(stdin);
scanf("%d",&f);
int freemem_s(){ if(f){
 c=(nod*)malloc(sizeof(nod)); printf("Proprietarul: %s\n",c->prop);
if(!c) return -3; printf("Adresa: %s\n",c->adresa);
printf("\nIntroduceti datele :\n");\ printf("Oralul: %s\n",c->oral);
printf("Denumirea: "); scanf("%s",&c- printf("Telefonul: %s\n",c->tel);
>denum);\ printf("Adresa elementului curent: %p\n",c);
printf("Proprietarul: "); scanf("%s",&c- printf("Adresa copilului drept: %p\n",c->right);
>prop);\ printf("Adresa copilului sting: %p\n\n",c->left);
printf("Adresa: "); scanf("%s",&c->adresa);\ show_RDS(c->right);
printf("Oralul: "); scanf("%s",&c- show_RDS(c->left);
>oral);\ }
printf("Telefonul: "); scanf("%s",&c- void show_DRS(nod *c){
>tel); if(!c){
p->left=c; return;
if(!push(c)) return -5; }
} else { show_DRS(c->right);
p->left=NULL; printf("Denumirea: %s\n",c->denum);
} printf("Proprietarul: %s\n",c->prop);
} printf("Adresa: %s\n",c->adresa);
} printf("Oralul: %s\n",c->oral);
return 1; printf("Telefonul: %s\n",c->tel);
} printf("Adresa elementului curent: %p\n",c);
printf("Adresa copilului drept: %p\n",c->right);
void show_r(nod *c){ printf("Adresa copilului sting: %p\n\n",c->left);
if(!c){ show_DRS(c->left);
return; }
} void show_DSR(nod *c){
printf("Denumirea: %s\n",c->denum); if(!c){
printf("Proprietarul: %s\n",c->prop); return;
printf("Adresa: %s\n",c->adresa); }
printf("Oralul: %s\n",c->oral); show_DSR(c->right);
printf("Telefonul: %s\n",c->tel); show_DSR(c->left);
printf("Adresa elementului curent: %p\n",c); printf("Denumirea: %s\n",c->denum);
printf("Adresa copilului drept: %p\n",c->right); printf("Proprietarul: %s\n",c->prop);
printf("Adresa copilului sting: %p\n\n",c->left); printf("Adresa: %s\n",c->adresa);
show_r(c->left); printf("Oralul: %s\n",c->oral);
show_r(c->right); printf("Telefonul: %s\n",c->tel);
} printf("Adresa elementului curent: %p\n",c);
void show_SRD(nod *c){ printf("Adresa copilului drept: %p\n",c->right);
if(!c){ printf("Adresa copilului sting: %p\n\n",c->left);
return; }
}
show_SRD(c->left); void freemem_r(nod *c){
printf("Denumirea: %s\n",c->denum); if(!c) return;
printf("Proprietarul: %s\n",c->prop); freemem_r(c->left);
printf("Adresa: %s\n",c->adresa); freemem_r(c->right);
printf("Oralul: %s\n",c->oral); free(c);
printf("Telefonul: %s\n",c->tel); }
printf("Adresa elementului curent: %p\n",c);
printf("Adresa copilului drept: %p\n",c->right);
printf("Adresa copilului sting: %p\n\n",c->left); nod* search_r(nod* c, char *fname){
show_SRD(c->right); nod* t=NULL;
} if(!c) return NULL;
void show_SDR(nod *c){ if (!strcmp(c->denum,fname)) return c;
if(!c){ t=search_r(c->left,fname);
return; if (t) return t;
} t=search_r(c->right,fname);
show_SDR(c->left); if (t) return t;
show_SDR(c->right); return NULL;
printf("Denumirea: %s\n",c->denum); }
printf("Proprietarul: %s\n",c->prop);
printf("Adresa: %s\n",c->adresa); int size_r(nod *c){
printf("Oralul: %s\n",c->oral); static int n=0;
printf("Telefonul: %s\n",c->tel); if(!c) return n;
printf("Adresa elementului curent: %p\n",c); n++;
printf("Adresa copilului drept: %p\n",c->right); size_r(c->left);
printf("Adresa copilului sting: %p\n\n",c->left); size_r(c->right);
} return n;
void show_RDS(nod *c){ }
if(!c){
return; int height_r(nod *c){
} int l,r;
printf("Denumirea: %s\n",c->denum); if(!c) return -1;
 l=height_r(c->left); case -3:
r=height_r(c->right); printf("\a\n Eroare la alocarea memoriei
if(l>r)return(l+1); pentru fecior! \n");
else{return(r+1); break;
} case -2:
} printf("\a\n Eroare la adaugarea nodului
in coada! \n");
void find_error(int ord){ break;
switch(ord){ case -1:
case -6: printf("\a\n Eroare la alocarea memoriei
printf("\a\n Eroare la crearea fisierului! pentru radacina! \n");
\n"); break;
break; case 0:
case -5: printf("\a\n Eroare ! \n"); break;
printf("\a\n Eroare la adaugarea nodului case 1:
in stiva! \n"); printf("\aOperatia a avut loc cu
break; succes!\n"); break;
case -4: default:
printf("\a\n Eroare la deschiderea printf("%d\n",ord); break;
fisierului! \n"); }
system("pause"); exit(1); break; }

Fisierul “main.cpp”
#include "funct.cpp" switch(comand){
int main(){ case 0:
int comand,m=1,m1=0,m2=0,m3=0; system("cls");
nod *t=NULL; printf("\n\t\t\n\n\n\n\n\t\t\t\tLa Revedere!!!");
char fname[10]; printf("\n\n\t\t\t\t (^_^)");
while(1){ getch();
fflush(stdin); exit(0);
while(m){m=0; system("cls"); fflush(stdin); break;
printf("\tCrearea arborelui case 1: m1=1; break;
:\n"); case 2: m2=1; break;
printf(" 1- prin coada\n"); case 3: m3=1; break;
printf(" 2- prin stiva\n"); case 4: m=1; break;
printf(" 3- prin functie default: printf("\a\nAti introdus o comanda
recursiva\n "); gresita!\n"); break;
printf("0- Exit\n "); }
printf("\tAlegeti optiunea: ");
fflush(stdin); while(m1){ system("cls"); fflush(stdin);
scanf("%d",&comand); printf("\t\tPrelucrarea arborelui binar folosind coada:\n");
system("cls"); printf("1- Afisarea informatiei\n");
switch(comand){ printf("2- Cautarea nodului dupa denumire\n");
case 0: printf("3- Marimea arborelui\n");
system("cls"); printf("4- Inaltimea arborelui!\n");
printf("\n\t\t\n\n\n\n\n\t\t\t\tLa Revedere!!!"); printf("5- Eliberarea memoriei\n");
printf("\n\n\t\t\t\t (^_^)"); printf("6- Alegerea modul de lucru\n\n");
getch(); printf("0- Exit\n\n");
exit(0); printf("Alegeti optiunea: ");
break; scanf("%d",&comand);
case 1: creat_q(); system("cls");
break; switch(comand){
case 2: creat_s(); case 0:
break; system("cls");
case 3: creat_r(); printf("\n\t\t\n\n\n\n\n\t\t\t\tLa Revedere!!!");
break; printf("\n\n\t\t\t\t (^_^)");
default: getch();
printf("\a\nAti introdus o comanda gresita!\n"); exit(0);
m=1; break; break;
}break; case 1:
} show_q(); break;
system("cls"); fflush(stdin); case 2:
printf("\tMeniu de lucru :\n"); printf("Introduceti denumirea casei de
printf("1- Coada\n"); schimb pentru cautare:\n");
printf("2- Stiva\n"); fflush(stdin); scanf("%s",&fname);
printf("3- Recursie\n"); t=search_q(fname);
printf("4- Meniul de introducere a datelor\n"); if(t){
printf("0- Exit\n\n"); printf("\nDenumirea: %s\n",t->denum);
printf("Alegeti optiunea: "); printf("Proprietarul: %s\n",t->prop);
scanf("%d",&comand); printf("Adresa: %s\n",t->adresa);
system("cls"); printf("Oralul: %s\n",t->oral);
 printf("Telefonul: %s\n",t->tel); default: printf("\a\nAti introdus o comanda
} else { gresita!\n"); break;
printf("Nu este asa casa de } pause
schimb\a"); }
} break; while(m3){ system("cls"); fflush(stdin);
case 3: printf("\t\tPrelucrarea arborelui binar recursiv:\n");
printf("Numarul de noduri a arborelui: printf(" 1 - RSD\n");
"); printf(" 2 - Cautarea nodului dupa denumire\n");
find_error(size_q()); break; printf(" 3 - Marimea arborelui\n");
case 4: printf(" 4 - Inaltimea arborelui!\n");
printf("Inaltimea arborelui: printf(" 5 - Eliberarea memoriei\n");
%d",height_r(root)); printf(" 6 - Alege modul de lucru\n");
break; printf(" 7 - SRD\n");
case 5: printf(" 8 - SDR\n");
freemem_q(); root=NULL; printf(" 9 - RDS\n");
printf("Memoria s-a eliberat cu printf("10 - DRS\n");
succes!"); printf("11 - DSR\n");
break; printf(" 0 - Exit\n\n");
case 6: m1=0; break; printf("Alegeti optiunea: ");
default: printf("\a\nAti introdus o comanda scanf("%d",&comand);
gresita!\n"); break; system("cls");
} pause switch(comand){
} case 0:
while(m2){ system("cls"); fflush(stdin); system("cls");
printf("\t\tPrelucrarea arborelui binar folosind stiva:\n"); printf("\n\t\t\n\n\n\n\n\t\t\t\tLa Revedere!!!");
printf("1- Afisarea informatiei\n"); printf("\n\n\t\t\t\t (^_^)");
printf("2- Cautarea nodului dupa denumire\n"); getch();
printf("3- Marimea arborelui\n"); exit(0);
printf("4- Inaltimea arborelui!\n"); break;
printf("5- Eliberarea memoriei\n"); case 1:
printf("6- Alege modul de lucru\n\n"); printf("RSD\n\n");
printf("0- Exit\n\n"); show_r(root); break;
printf("Alegeti optiunea: "); case 2:
scanf("%d",&comand); printf("Introduceti denumirea casei de
system("cls"); schimb pentru cautare:\n");
switch(comand){ fflush(stdin); scanf("%s",&fname);
case 0: t=search_r(root,fname);
system("cls"); if(t){
printf("\n\t\t\n\n\n\n\n\t\t\t\tLa Revedere!!!"); printf("\nDenumirea: %s\n",t->denum);
printf("\n\n\t\t\t\t (^_^)"); printf("Proprietarul: %s\n",t->prop);
getch(); printf("Adresa: %s\n",t->adresa);
exit(0); printf("Oralul: %s\n",t->oral);
break; printf("Telefonul: %s\n",t->tel);
case 1: } else {
show_s(); break; printf("Nu este asa casa de
case 2: schimb!\a");
printf("Introduceti denumirea casei de } break;
schimb pentru cautare:\n"); case 3:
fflush(stdin); scanf("%s",&fname); printf("Numarul de noduri a arborelui:
t=search_s(fname); ");
if(t){ find_error(size_r(root)); break;
printf("\nDenumirea: %s\n",t->denum); case 4:
printf("Proprietarul: %s\n",t->prop); printf("Inaltimea arborelui:
printf("Adresa: %s\n",t->adresa); %d",height_r(root));
printf("Oralul: %s\n",t->oral); break;
printf("Telefonul: %s\n",t->tel); case 5:
} else { freemem_r(root); root=NULL;
printf("Nu este asa casa de printf("Eliberarea memoriei a avut loc
schimb!\a"); cu succes!\a");
} break; break;
case 3: case 6: m3=0; break;
printf("Numarul de noduri a arborelui: case 7: printf("SRD\n\n");
"); show_SRD(root); break;
find_error(size_s()); break; case 8: printf("SDR\n\n");
case 4: show_SDR(root); break;
printf("Inaltimea arborelui: case 9: printf("RDS\n\n");
%d",height_r(root)); show_RDS(root); break;
break; case 10: printf("DRS\n\n");
case 5:freemem_s(); root=NULL; show_DRS(root); break;
printf("Memoria s-a eliberat cu succes!"); case 11: printf("DSR\n\n");
break; show_DSR(root); break;
case 6: m2=0; break;
 default: printf("\a\nAti introdus o comanda }
gresita!\n"); break; return 0;
} pause }
}

Rezultatele obtinute:

Meniu

Crearea prin funcția recursivă

 Meniul de lucru

Mărimea arborelui

Înălțimea arborelui

Cautarea
SRD

DSR