MINISTERUL EDUCATIEI, CULTURII

ȘI CERCETĂRII AL REPUBLICII MOLDOVA

UNIVERSITATEA TEHNICA A MOLDOVEI
Facultatea Calculatoare, Informatică și Microelectronică

RAPORT
Structuri de date și algoritmi
Lucrare de laborator nr. 10/11

Tema: Implementarea tipului abstract de date „Arbore

binar”. Utilizarea algoritmilor iterativi.

Varianta: 5

Efectuat st. gr. CR-211 Cobzac D

Verificat conf. univ., dr. Kulev M

Chișinău 2022
 Scopul lucrării: Obţinerea deprinderilor practice de implementare și de
utilizare a tipului abstract de date (TAD) „Arbore binar” cu asigurarea operațiilor
de prelucrare de bază ale arborelui binar oarecare prin parcurgerea nodurilor
arborelui “în lăţime” şi “în adâncime”, folosind structurile respective de date
“coadă” şi “stivă”.

Sarcina lucrării: Să se scrie trei fişiere-text în limbajul C pentru

implementarea și utilizarea TAD „Arbore binar” cu asigurarea operațiilor de
prelucrare de bază ale arborelui binar oarecare prin parcurgerea nodurilor
arborelui cu ajutorul algoritmilor iterativi:
1. Fişier antet cu extensia .h, care conține specificarea structurii de date a
nodului arborelui binar (conform variantelor) şi a structurilor de date ale
elementelor cozii și stivei, precum și prototipurile funcţiilor de prelucrare ale
arborelui binar oarecare, bazate pe algoritmi iterativi.
2. Fişier cu extensia .cpp sau .c, care conține implementările funcţiilor
(codurile funcţiilor), declarate în fişierul antet.
3. Fişier al utilizatorului, funcţia mаin() pentru prelucrarea arborelui binar
oarecare cu afişarea la ecran a următorului meniu de opţiuni:
1. Crearea nodurilor arborelui binar oarecare în memoria dinamică și
introducerea informaţiei despre nodurile arborelui de la tastatură în mod
interactive.
2. Afişarea informaţiei despre nodurile arborelui la ecran.

Varianta: Structura Marfă cu câmpurile: denumirea, țara, producătorul,

articolul, prețul.

Programul elaborat:

Cod sursa lab4.h

typedef struct Marfa

{
char name[30];
char owner[30];
char type[30];
char addr[30];
int surf;
int price;
struct Marfa *left;
struct Marfa *right;
}Marfa;
Marfa *root = NULL;
typedef struct ElQueue
2
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 {
Marfa *adr;
struct ElQueue *next;
}ElQueue;
ElQueue *first, *last;
typedef struct ElStack
{
Marfa *adr;
struct ElStack *prev;
}ElStack;
ElStack *top;
int inQueue(Marfa *v);
Marfa* delQueue(void);
int push(Marfa *v);
Marfa *pop(void);
int createQueue(void);
int createStack(void);
int createRecursion(void);
int show_treeQueue(void);
int show_treeStack(void);
Marfa *search_treeQueue(char *v);
Marfa *search_treeStack(char *v);
Marfa *search_treeRecursion(Marfa *c, char *nume);
void modify_information(Marfa *a);
int size_treeQueue(void);
int size_treeStack(void);
int size_treeRecursion(Marfa *c);
int height_tree(Marfa *c);
int free_mem_treeQueue(void);
int free_mem_treeStack(void);
int free_mem_treeRecusion(Marfa *c);
void RDS(Marfa *c);
void RSD(Marfa *c);
void SRD(Marfa *c);
void DRS(Marfa *c);
void SDR(Marfa *c);
void DSR(Marfa *c);

Cod sursa functii.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "lab4.h"
Marfa *pop(void)
{
ElStack *t;
Marfa *v;
t = top;
v = t->adr;
3
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 top = t->prev;
free(t);
return v;
}
int createQueue(void)
{
Marfa *p, *s;
int d, f;
root = NULL;
first = last = NULL;
printf("Doriti sa creati un arbore(radacina)? (1/0): ");
scanf("%d", &f);
if(f == 0)
{
puts("Arborele nu a fost creat, memoria nu a fost alocata!");
return 0;
}
p = (Marfa*)malloc(sizeof(*p));
if(p == NULL)
{
return -1;
}
puts("Memoria a fost alocata cu succes!");
puts("\nDati informatia pentru radacina: ");
puts("________________________________");
printf("- Denumire: ");
fflush(stdin);
gets(p->name);
printf("- Proprietar: ");
fflush(stdin);
gets(p->owner);
printf("- Tip: ");
fflush(stdin);
gets(p->type);
printf("- Adresa: ");
fflush(stdin);
gets(p->addr);
printf("- Suprafata: ");
scanf("%d", &p->surf);
printf("- Pret: ");
scanf("%d", &p->price);
d = inQueue(p);
if(d == 0)
{
return -2;
}
root = p;
while(first!=NULL)
{
p = delQueue();
printf("\nDoriti sa creati copilul stang al nodului %s ? (1/0): ", p->name);
4
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 scanf("%d", &f);
if(f!=0)
{
s = (Marfa*)malloc(sizeof(*s));
if(s == NULL)
{
return -3;
}
p->left = s;
puts("Dati informatia pentru nod:");
puts("___________________________");
printf("- Denumire: ");
fflush(stdin);
gets(s->name);
printf("- Proprietar: ");
fflush(stdin);
gets(s->owner);
printf("- Tip: ");
fflush(stdin);
gets(s->type);
printf("- Adresa: ");
fflush(stdin);
gets(s->addr);
printf("- Suprafata: ");
scanf("%d", &s->surf);
printf("- Pret: ");
scanf("%d", &s->price);
d = inQueue(s);
if(d == 0)
{
return -2;
}
} else {
p->left = NULL;
}
printf("\nDoriti sa creati copilul drept al nodului %s? (1/0): ", p->name);
scanf("%d", &f);
if(f!=0)
{
s = (Marfa*)malloc(sizeof(*s));
if(s == NULL){
return -3;
}
p->right = s;
puts("Dati informatia pentru nod:");
puts("___________________________");
printf("- Denumire: ");
fflush(stdin);
gets(s->name);
printf("- Proprietar: ");
fflush(stdin);
5
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 gets(s->owner);
printf("- Tip: ");
fflush(stdin);
gets(s->type);
printf("- Adresa: ");
fflush(stdin);
gets(s->addr);
printf("- Suprafata: ");
scanf("%d", &s->surf);
printf("- Pret: ");
scanf("%d", &s->price);
d = inQueue(s);
if(d == 0)
{
return -2;
}
} else {
p->right = NULL;
}
}
return 1;
}
int createStack(void)
{
Marfa *p, *s;
int d, f;
root = NULL;
top = NULL;
printf("\nDoriti sa creati un arbore(radacina)? (1/0): ");
scanf("%d", &f);
if(f == 0)
{
puts("Arborele nu a fost creat.");
return 0;
}
p = (Marfa*)malloc(sizeof(*p));
if(p == NULL)
{
return -1;
}
puts("Memoria a fost alocata cu succes!");
puts("\nDati informatia pentru radacina: ");
puts("___________________________________");
printf("- Denumire: ");
fflush(stdin);
gets(p->name);
printf("- Proprietar: ");
fflush(stdin);
gets(p->owner);
printf("- Tip: ");
fflush(stdin);
6
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 gets(p->type);
printf("- Adresa: ");
fflush(stdin);
gets(p->addr);
printf("- Suprafata: ");
scanf("%d", &p->surf);
printf("- Pret: ");
scanf("%d", &p->price);
d = push(p);
if(d == 0)
{
return -2;
}
root = p;
while(top!=NULL)
{
p = pop();
printf("Doriti sa creati copilul drept al nodului %s? (1/0): ", p->name);
scanf("%d", &f);
if(f!=0)
{
s = (Marfa*)malloc(sizeof(*s));
if(s == NULL)
{
return -3;
}
p->right = s;
puts("\nDati informatia pentru nod:");
puts("______________________________");
printf("- Denumire: ");
fflush(stdin);
gets(s->name);
printf("- Proprietar: ");
fflush(stdin);
gets(s->owner);
printf("- Tip: ");
fflush(stdin);
gets(s->type);
printf("- Adresa: ");
fflush(stdin);
gets(s->addr);
printf("- Suprafata: ");
scanf("%d", &s->surf);
printf("- Pret: ");
scanf("%d", &s->price);
d = push(s);
if(d == 0)
{
return -2;
}
} else {
7
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 p->right = NULL;
}
printf("\nDoriti sa creati copilul sting al nodului %s? (1/0): ", p->name);
scanf("%d", &f);
if(f!=0)
{
s = (Marfa*)malloc(sizeof(*s));
if(s == NULL)
{
return -3;
}
p->left = s;
puts("\nDati informatia pentru nod:");
puts("______________________________");
printf("- Denumire: ");
fflush(stdin);
gets(s->name);
printf("- Proprietar: ");
fflush(stdin);
gets(s->owner);
printf("- Tip: ");
fflush(stdin);
gets(s->type);
printf("- Adresa: ");
fflush(stdin);
gets(s->addr);
printf("- Suprafata: ");
scanf("%d", &s->surf);
printf("- Pret: ");
scanf("%d", &s->price);
d = push(s);
if(d == 0)
{
return -2;
}
} else {
p->left = NULL;
}
}
return 1;
}
int createRecursion(void)
{
Marfa *s;
int f;
printf("(1/0): ");
scanf("%d", &f);
if(f == 0)
{
return NULL;
}
8
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 s = (Marfa*)malloc(sizeof(*s));
if(s == NULL)
{
printf("Memoria nu a fost alocata!\n");
exit(1);
}
puts("\nDati informatia pentru nod: ");
puts("______________________________");
printf("- Denumire: ");
fflush(stdin);
gets(s->name);
printf("- Proprietar: ");
fflush(stdin);
gets(s->owner);
printf("- Tip: ");
fflush(stdin);
gets(s->type);
printf("- Adresa: ");
fflush(stdin);
gets(s->addr);
printf("- Suprafata: ");
scanf("%d", &s->surf);
printf("- Pret: ");
scanf("%d", &s->price);
printf("\n- Dati fiul sting al tatalui %s ", s->name);
s->left = createRecursion();
printf("\n- Dati fiul drept al tatalui %s ", s->name);
s->right = createRecursion();
return s;
}
int show_treeQueue(void)
{
Marfa *p, *s;
int d;
first = last = NULL;
p = root;
d = inQueue(p);
if(d == 0)
{
return -2;
}
puts("\nInformatia despre noduri:");
puts("___________________________________________");
while(first!=NULL)
{
p = delQueue();
printf("- Denumire: %s\n", p->name);
printf("- Proprietar: %s\n", p->owner);
printf("- Tip: %s\n", p->type);
printf("- Adresa: %s\n", p->addr);
printf("- Suprafata: %d\n", p->surf);
9
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 printf("- Pret: %d\n", p->price);
printf("- Nodul: %x; Left: %x, Right: %x\n", p, p->left, p->right);
puts("___________________________________________");
s = p->left;
if(s)
{
d = inQueue(s);
if(d == 0)
{
return -2;
}
}
s = p->right;
if(s)
{
d = inQueue(s);
if(d == 0)
{
return -2;
}
}
}
return 1;
}
int show_treeStack(void)
{
Marfa *p, *s;
int d;
top = NULL;
p = root;
d = push(p);
if(d == 0)
{
return -2;
}
puts("\nInformatii despre nod:");
puts("___________________________________________");
while(top!=NULL)
{
p = pop();
printf("- Denumire: %s\n", p->name);
printf("- Proprietar: %s\n", p->owner);
printf("- Tip: %s\n", p->type);
printf("- Adresa: %s\n", p->addr);
printf("- Suprafata: %d\n", p->surf);
printf("- Pret: %d\n", p->price);
printf("- Nodul: %x; Left: %x, Right: %x\n", p, p->left, p->right);
puts("___________________________________________");
s = p->right;
if(s)
{
10
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 d = push(s);
if(d == 0)
{
return -2;
}
}
s = p->left;
if(s)
{
d = push(s);
if(d == 0)
{
return -2;
}
}
}
return 1;
}
int inQueue(Marfa *v)
{
ElQueue *t;
t = (ElQueue*)calloc(1,sizeof(*t));
if(t == NULL) return 0;
t->adr = v;
t->next = NULL;
if(first == NULL)
{
first = t;
} else {
last->next = t;
}
last = t;
return 1;
}
Marfa *delQueue(void)
{
ElQueue *t;
Marfa *v;
t = first;
v = t->adr;
if(t == last)
{
first = last = NULL;
} else {
first = t->next;
}
free(t);
return v;
}
int push(Marfa *v)
{
11
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 ElStack *t;
t = (ElStack*)calloc(1,sizeof(*t));
if(t == NULL)
{
return 0;
}
t->adr = v;
t->prev = top;
top = t;
return 1;
}
Marfa *search_treeQueue(char *v)
{
Marfa *p, *s;
int d;
first = last = NULL;
p = root;
d = inQueue(p);
if(d == 0)
{
return NULL;
}
while(first!=NULL)
{
p = delQueue();
if(stricmp(p->name, v)==0)
{
return p;
}
s = p->left;
if(s)
{
d = inQueue(s);
if(d == 0)
{
return NULL;
}
}
s = p->right;
if(s)
{
d = inQueue(s);
if(d == 0)
{
return NULL;
}
}
}
return NULL;
}
Marfa *search_treeStack(char *v)
12
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 {
Marfa *p, *s;
top = NULL;
int d;
d = push(root);
if(d == 0)
{
return NULL;
}
while(top!=NULL)
{
p = pop();
if(stricmp(p->name, v)==0)
{
return p;
}
s = p->left;
if(s!=NULL)
{
push(s);
}
s = p->right;
if(s!=NULL)
{
push(s);
}
}
return NULL;
}
Marfa *search_treeRecursion(Marfa *c, char *nume)
{
Marfa *temp = NULL;
if(c == NULL)
{
return NULL;
}
if(strcmp(c->name, nume)==0)
{
return c;
}
temp = search_treeRecursion(c->left, nume);
if(temp)
{
return temp;
}
temp = search_treeRecursion(c->right, nume);
if(temp)
{
return temp;
}
return NULL;
13
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 }
void modify_information(Marfa *c)
{
int f;
printf("Doriti sa modificati denumirea imobilului? (1/0): ");
scanf("%d", &f);
if(f!=0)
{
printf("Dati denumirea imobilului: ");
fflush(stdin);
gets(c->name);
}
printf("Doriti sa modificati proprietarul imobilului? (1/0): ");
scanf("%d", &f);
if(f!=0)
{
printf("Dati proprietarul: ");
fflush(stdin);
gets(c->owner);
}
printf("Doriti sa modificati tipul imobilului? (1/0): ");
scanf("%d", &f);
if(f!=0)
{
printf("Dati tipul: ");
fflush(stdin);
gets(c->type);
}
printf("Doriti sa modificati adresa imobilului? (1/0): ");
scanf("%d", &f);
if(f!=0)
{
printf("Dati adresa: ");
fflush(stdin);
gets(c->addr);
}
printf("Doriti sa modificati suprafata imobilului? (1/0): ");
scanf("%d", &f);
if(f!=0)
{
printf("Dati suprafata: ");
scanf("%d", &c->surf);
}
printf("Doriti sa modificati pretul imobilului? (1/0): ");
scanf("%d", &f);
if(f!=0)
{
printf("Dati pretul: ");
scanf("%d", &c->price);
}
return;
14
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 }
int size_treeQueue(void)
{
Marfa *p, *s;
int d;
int n = 0;
first = last = NULL;
p = root;
d = inQueue(p);
if(d == 0)
{
return -2;
}
while(first!=NULL)
{
p = delQueue();
n++;
s = p->left;
if(s)
{
d = inQueue(s);
if(d == 0)
{
return -2;
}
}
s = p->right;
if(s)
{
d = inQueue(s);
if(d == 0)
{
return -2;
}
}
}
return n;
}
int size_treeStack(void)
{
Marfa *p, *s;
int d;
int n = 0;
top = NULL;
p = root;
d = push(p);
if(d == 0)
{
return -2;
}
while(top!=NULL)
15
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 {
p = pop();
n++;
s = p->right;
if(s)
{
d = push(s);
if(d == 0)
{
return -2;
}
}
s = p->left;
if(s)
{
d = push(s);
if(d == 0)
{
return -2;
}
}
}
return n;
}
int size_treeRecursion(Marfa *c)
{
if(c == NULL)
{
return;
}
return 1 + size_treeRecursion(c->left) + size_treeRecursion(c->right);
}
int height_tree(Marfa *c)
{
if(c)
{
int h_left = height_tree(c->left);
int h_right = height_tree(c->right);
int n = 1;
if(h_left > h_right)
{
n = h_left;
} else {
n = h_right;
}
n++;
return n;
// return 1 + height_treeQueue(c->left) + height_treeQueue(c->right);
} else {
return 0;
}
16
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 }
int free_mem_treeQueue(void)
{
Marfa* p, *s;
int d;
first = last = NULL;
p = root;
d = inQueue(p);
if(d == 0)
{
return -2;
}
while(first!=NULL)
{
p = delQueue();
s = p->left;
if(s)
{
d = inQueue(s);
if(d == 0)
{
return -2;
}
}
s = p->right;
if(s)
{
d = inQueue(s);
if(d == 0)
{
return -2;
}
}
free(p);
}
return 1;
}
int free_mem_treeStack(void)
{
Marfa *p, *s;
int d;
top = NULL;
p = root;
d = push(p);
if(d == 0)
{
return -2;
}
while(top!=NULL)
{
p = pop();
17
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 s = p->right;
if(s)
{
d = push(s);
if(d == 0)
{
return -2;
}
}
s = p->left;
if(s)
{
d = push(s);
if(d == 0)
{
return -2;
}
}
free(p);
}
return 1;
}
int free_mem_treeRecusion(Marfa *c)
{
if(c)
{
free_mem_treeRecusion(c->left);
free_mem_treeRecusion(c->right);
free(c);
c = NULL;
}
}
void RDS(Marfa *c)
{
if(c == NULL)
{
return;
}
puts("___________________________________________");
printf("- Denumire: %s\n", c->name);
printf("- Proprietar: %s\n", c->owner);
printf("- Tip: %s\n", c->type);
printf("- Adresa: %s\n", c->addr);
printf("- Suprafata: %d\n", c->surf);
printf("- Pret: %d\n", c->price);
printf("- Nodul: %x; Left: %x, Right: %x\n", c, c->left, c->right);
puts("___________________________________________");
RDS(c->right);
RDS(c->left);
}
void RSD(Marfa *c)
18
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 {
if(c == NULL)
{
return;
}
puts("___________________________________________");
printf("- Denumire: %s\n", c->name);
printf("- Proprietar: %s\n", c->owner);
printf("- Tip: %s\n", c->type);
printf("- Adresa: %s\n", c->addr);
printf("- Suprafata: %d\n", c->surf);
printf("- Pret: %d\n", c->price);
printf("- Nodul: %x; Left: %x, Right: %x\n", c, c->left, c->right);
puts("___________________________________________");
RSD(c->left);
RSD(c->right);
}
void SRD(Marfa *c)
{
if(c == NULL)
{
return;
}
SRD(c->left);
puts("___________________________________________");
printf("- Denumire: %s\n", c->name);
printf("- Proprietar: %s\n", c->owner);
printf("- Tip: %s\n", c->type);
printf("- Adresa: %s\n", c->addr);
printf("- Suprafata: %d\n", c->surf);
printf("- Pret: %d\n", c->price);
printf("- Nodul: %x; Left: %x, Right: %x\n", c, c->left, c->right);
puts("___________________________________________");
SRD(c->right);
}
void DRS(Marfa *c)
{
if(c == NULL)
{
return;
}
DSR(c->right);
puts("___________________________________________");
printf("- Denumire: %s\n", c->name);
printf("- Proprietar: %s\n", c->owner);
printf("- Tip: %s\n", c->type);
printf("- Adresa: %s\n", c->addr);
printf("- Suprafata: %d\n", c->surf);
printf("- Pret: %d\n", c->price);
printf("- Nodul: %x; Left: %x, Right: %x\n", c, c->left, c->right);
puts("___________________________________________");
19
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 DSR(c->left);
}
void SDR(Marfa *c)
{
if(c == NULL)
{
return;
}
SDR(c->left);
SDR(c->right);
puts("___________________________________________");
printf("- Denumire: %s\n", c->name);
printf("- Proprietar: %s\n", c->owner);
printf("- Tip: %s\n", c->type);
printf("- Adresa: %s\n", c->addr);
printf("- Suprafata: %d\n", c->surf);
printf("- Pret: %d\n", c->price);
printf("- Nodul: %x; Left: %x, Right: %x\n", c, c->left, c->right);
puts("___________________________________________");
}
void DSR(Marfa *c)
{
if(c == NULL)
{
return;
}
DSR(c->right);
DSR(c->left);
puts("___________________________________________");
printf("- Denumire: %s\n", c->name);
printf("- Proprietar: %s\n", c->owner);
printf("- Tip: %s\n", c->type);
printf("- Adresa: %s\n", c->addr);
printf("- Suprafata: %d\n", c->surf);
printf("- Pret: %d\n", c->price);
printf("- Nodul: %x; Left: %x, Right: %x\n", c, c->left, c->right);
puts("___________________________________________");
}

Cod sursa main.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
#include "functii.c"

20
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 int main()
{
Marfa *p = NULL;
int f, height;
char num[40];
int op;
for(;;)
{
system("cls");

puts("|
===================================================================
===|");
puts("| MENIU(coada): |");
puts("|
===================================================================
===|");
puts("| 1. Crearea nodurilor arborelui binar oarecare in memoria dinamica... |");
puts("| 2. Afisarea informatiei despre nodurile arborelui la ecran. |");
puts("| 3. Cautarea nodului in arbore. |");
puts("| 4. Modificarea informatiei unui nod din arbore. |");
puts("| 5. Determinarea numarului de noduri. |");
puts("| 6. Determinarea inaltimii arborelui. |");
puts("| 7. Eliberarea memoriei alocate pentru arbore. |");
puts("| 0. Iesirea din program. |");
puts("|
===================================================================
===|\n");
puts("|
===================================================================
===|");
puts("| MENIU(stiva): |");
puts("|
===================================================================
===|");
puts("| 8. Crearea nodurilor arborelui binar oarecare in memoria dinamica... |");
puts("| 9. Afisarea informatiei despre nodurile arborelui la ecran. |");
puts("| 10. Cautarea nodului in arbore. |");
puts("| 11. Modificarea informatiei unui nod din arbore. |");
puts("| 12. Determinarea numarului de noduri. |");
puts("| 13. Determinarea inaltimii arborelui. |");
puts("| 14. Eliberarea memoriei alocate pentru arbore. |");
puts("| 15. Iesirea din program. |");
puts("|
===================================================================
===|\n");
puts("|
===================================================================
===|");
puts("| MENIU(Recursie): |");
puts("|
21
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 ===================================================================
===|");
puts("| 16. Crearea nodurilor arborelui binar oarecare in memoria dinamica...|");
puts("| 17. Cautarea nodului in arbore. |");
puts("| 18. Modificarea informatiei unui nod din arbore. |");
puts("| 19. Determinarea numarului de noduri. |");
puts("| 20. Determinarea inaltimii arborelui. |");
puts("| 21. Eliberarea memoriei alocate pentru arbore. |");
puts("| 22. Iesirea din program. |");
puts("|
===================================================================
===|\n");
puts("|=============================|");
puts("| 23)RDS |");
puts("| 24)RSD |");
puts("| 25)SRD |");
puts("| 26)DRS |");
puts("| 27)SDR |");
puts("| 28)DSR |");
puts("|=============================|");
printf("\nAlegeti optiunea meniului: ");
scanf("%d", &op);
switch(op)
{
case 1:
f = createQueue();
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 2:
f = show_treeQueue();
if(f == 0)
{
puts("Memoria nu a fost alocata.");
exit(1);
}
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 3:
printf("Dati numele imobilului ce doriti sa-l cautati: ");
fflush(stdin);
gets(num);
p = search_treeQueue(num);
if(p == NULL)
{
puts("Nodul nu a fost gasit.");
} else {
puts("\nInformatii despre nod:");
puts("_____________________________");
printf("- Denumire: %s\n", p->name);
22
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 printf("- Proprietar: %s\n", p->owner);
printf("- Tip: %s\n", p->type);
printf("- Adresa: %s\n", p->addr);
printf("- Suprafata: %d\n", p->surf);
printf("- Pret: %d\n", p->price);
printf("- Nodul: %x; Left: %x, Right: %x\n", p, p->left, p->right);
}
puts("\nPentru a continua apasati orice tasta...");
getch();
break;
case 4:
printf("Dati numele imobilului informatia caruia doriti sa o modificati: ");
fflush(stdin);
gets(num);
p = search_treeQueue(num);
if(p == NULL)
{
puts("Nu exista asa nod in arbore, incercati din nou!");
} else {
puts("\nInformatii despre nod:");
puts("________________________________");
printf("- Denumire: %s\n", p->name);
printf("- Proprietar: %s\n", p->owner);
printf("- Tip: %s\n", p->type);
printf("- Adresa: %s\n", p->addr);
printf("- Suprafata: %d\n", p->surf);
printf("- Pret: %d\n", p->price);
printf("- Nodul: %x; Left: %x, Right: %x\n\n", p, p->left, p->right);
modify_information(p);
}
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 5:
f = size_treeQueue();
if(f == 0)
{
puts("Memoria nu a fost alocata!");
} else {
printf("Numarul de noduri este: %d\n", f);
}
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 6:
height = height_tree(root);
printf("Inaltimea arborelui este de %d NIVELE.\n", height);
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 7:
23
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 free_mem_treeQueue();
puts("Memoria a fost eliberata cu succes!");
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 0:
puts("\nProgramul a fost inchis cu succes.");
return 0;
exit(1);
case 8:
f = createStack();
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 9:
f = show_treeStack();
if(f == 0)
{
puts("Memoria nu a fost alocata.");
exit(1);
}
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 10:
printf("Dati numele marfei ce doriti sa cautati: ");
fflush(stdin);
gets(num);
p = search_treeStack(num);
if(p == NULL)
{
puts("Nodul nu a fost gasit.");
} else {
puts("\nInformatii despre nod:");
puts("___________________________________________");
printf("- Denumire: %s\n", p->name);
printf("- Proprietar: %s\n", p->owner);
printf("- Tip: %s\n", p->type);
printf("- Adresa: %s\n", p->addr);
printf("- Suprafata: %d\n", p->surf);
printf("- Pret: %d\n", p->price);
printf("- Nodul: %x; Left: %x, Right: %x\n", p, p->left, p->right);
}
puts("\nPentru a continua apasati orice tasta...");
getch();
break;
case 11:
printf("Dati numele imobilului informatia caruia doriti sa o modificati: ");
fflush(stdin);
gets(num);
p = search_treeStack(num);
24
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 if(p == NULL)
{
puts("Nu exista asa nod in arbore, incercati din nou!");
} else {
puts("Informatii despre nod:");
puts("__________________________________");
printf("- Denumire: %s\n", p->name);
printf("- Proprietar: %s\n", p->owner);
printf("- Tip: %s\n", p->type);
printf("- Adresa: %s\n", p->addr);
printf("- Suprafata: %d\n", p->surf);
printf("- Pret: %d\n", p->price);
printf("- Nodul: %x; Left: %x, Right: %x\n\n", p, p->left, p->right);
modify_information(p);
}
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 12:
f = size_treeStack();
if(f == 0)
{
puts("Memoria nu a fost alocata!");
} else {
printf("Numarul de noduri este: %d\n", f);
}
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 13:
height = height_tree(root);
printf("Inaltimea arborelui este de %d NIVELE.\n", height);
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 14:
free_mem_treeStack();
puts("Memoria a fost eliberata cu succes!");
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 15:
puts("\nProgramul a fost inchis cu succes.");
return 0;
exit(1);
case 16:
f = createRecursion();
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 17:
25
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 printf("Dati numele imobilului ce doriti sa-l cautati: ");
fflush(stdin);
gets(num);
p = search_treeRecursion(root, num);
if(p == NULL)
{
puts("Nodul nu a fost gasit.");
} else {
puts("\nInformatii despre nod:");
puts("________________________________________________");
printf("- Denumire: %s\n", p->name);
printf("- Proprietar: %s\n", p->owner);
printf("- Tip: %s\n", p->type);
printf("- Adresa: %s\n", p->addr);
printf("- Suprafata: %d\n", p->surf);
printf("- Pret: %d\n", p->price);
printf("- Nodul: %x; Left: %x, Right: %x\n", p, p->left, p->right);
puts("________________________________________________");
}
puts("\nPentru a continua apasati orice tasta...");
getch();
break;
case 18:
printf("Dati numele imobilului informatia caruia doriti sa o modificati: ");
fflush(stdin);
gets(num);
p = search_treeRecursion(root, num);
if(p == NULL)
{
puts("Nu exista asa nod in arbore, incercati din nou!");
} else {
puts("\nInformatii despre nod:");
puts("________________________________________________");
printf("- Denumire: %s\n", p->name);
printf("- Proprietar: %s\n", p->owner);
printf("- Tip: %s\n", p->type);
printf("- Adresa: %s\n", p->addr);
printf("- Suprafata: %d\n", p->surf);
printf("- Pret: %d\n", p->price);
printf("- Nodul: %x; Left: %x, Right: %x\n\n", p, p->left, p->right);
puts("________________________________________________");
modify_information(p);
}
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 19:
f = size_treeRecursion(root);
if(f == 0)
{
puts("Memoria nu a fost alocata!");
26
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 } else {
printf("Numarul de noduri este: %d\n", f);
}
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 20:
height = height_tree(root);
printf("Inaltimea arborelui este de %d NIVELE.\n", height);
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 21:
f = free_mem_treeRecusion(root);
puts("Memoria a fost eliberata cu succes!");
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 22:
puts("\nProgramul a fost inchis cu succes.");
return 0;
exit(1);
case 23:
RDS(root);
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 24:
RSD(root);
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 25:
SRD(root);
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 26:
DRS(root);
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 27:
SDR(root);
puts("Pentru a continua apasati orice tasta...");
getch();
break;
case 28:
DSR(root);
puts("Pentru a continua apasati orice tasta...");
getch();
27
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 break;
default:
puts("Ati ales o optiune incorecta, incercati din nou.");
puts("Pentru a continua apasati orice tasta...");
getch();
}
}
}

Rezultatele primite:

Meniul principal

Crearea listei înlănțuite

Introducerea informației despre marfă

Afișsarea datelor

Căutarea elementului in listă

Interschimbarea a două elemente

Sortarea elementelor după nume

Modificarea elementului

28
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 Stergerea elementului

Salvarea în fișier

Citirea din fișier

Adăugarea unui nou element de la început

Adăugarea unui nou element la sfârșit

Introducerea unui element după altul

Introducerea unui element înaintea altuia

Lungimea listei sau numărul de elemente

Afișarea listei modificate:

Divizarea în 2 subliste
29
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.
 Unirea a 2 subliste

Eliberarea memoriei

Concluzie: În urma efectuării acestei lucrări practice am căpătat deprinderi

în programarea și implementarea a tipului abstract de date “Lista unidirecțională”
în limbajul de programare C++. A fost elaborat un program care vă permite să
editați toate datele din baza de date: să adăugați marfă nouă, să le editați, să le
adăugați, să le ștergeți, să le sortați și în final aveți posibilitatea să salvați toate
informațiile într-un fișier și să le citiți dintr-un fișier. Am folosit lista legată și am
putut observa câteva avantaje ale acestora, cum ar fi:
 Nu este necesar să cunoașteți în avans numărul de elemente care trebuie
stocate în listă și, prin urmare, nu trebuie alocat.
 Într-o listă legată, inserările și ștergerile pot fi manipulate eficient fără a fixa
dimensiunea memoriei în avans.
 Un avantaj important al listelor conectate prin intermediul rețelelor este
faptul că lista conectată utilizează exact aceeași memorie de care are nevoie
și poate fi extinsă pentru a umple toate locațiile de memorie disponibile dacă
este necesar.
De asemenea, am observat unele dezavantaje ale acestora, ca:
 Traversarea este secvențială.
 Creșterea cheltuielilor pentru stocarea indicatorilor pentru conectarea
elementelor de date.

30
Structuri de date și algoritmi. Lucrare de laborator Nr.10/11
Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor iterativi.