Ministerul Educaţiei

al Republicii Moldova

Universitatea Tehnică a Moldovei

Catedra Calculatoare și Rețele

RAPORT
despre lucrarea de laborator Nr. 10-11
la Structuri de date şi algoritmi 

Tema: Implementarea tipului abstract de date „Arbore binar”. Utilizarea algoritmilor

iterativi/recursivi

A efectuat:
st. gr. CR-191 Axenti Alina

A verificat:
Lector univ. Munteanu Silvia

Chişinău – 2021
 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 recursivă a nodurilor arborelui, folosind algoritmi recursivi.

Sarcina (conform variantelor) :

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 recursivi:

1. Fişier antet cu extensia .h, care conține specificarea structurii de date a nodului arborelui binar
(conform variantelor) şi prototipurile funcţiilor de prelucrare ale arborelui binar oarecare, bazate pe
algoritmi recursivi.
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.
3. Căutarea nodului în arbore.
4. Modificarea informației a unui nod din arbore.
34
5. Determinarea numărului de noduri.
6. Determinarea înălţimii arborelui.
7. Eliberarea memoriei alocate pentru arbore.
0. Ieşirea din program.

Varianta 2. Structura Film cu câmpurile: denumirea, ţara, regizorul, genul filmului, anul.

Mersul lucrării:
Noțiuni teoretice:

•Biblioteca stdio.h conține funcții speciale pentru citirea și afișarea datelor – prin urmare instrucțiunea
de includere a acesteia va fi practic prezentă în orice program. #include <stdio.h>;
•Int-variabila simpla de tip integer(intreg);
•While-execută un bloc de instrucţiuni atâta timp cât o anumită condiţie este adevărată;
•Printf-pentru afișarea datelor;
•Scanf-pentru citirea datelor;
•If,-instrucțiune;
•Malloc-funcție de alocare are ca rezultat adresa zonei de memorie alocate (de tip void*);
 Codul programului în C

Main_film.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "film.h"
int main(){

Node* root;
int c, ult = 1;;

while(ult){
#ifdef OSisWindows
system("cls");
#else
system("clear");
#endif

print_menu();
printf("\nAlegeti punctul din meniu: ");
scanf("%d", &c);
switch (c){
case 1: {
int n, i;
char left_right[10];
printf("\nNumarul de elemente in arbore: ");
scanf("%d", &n);
root = new_node(input_data());
for(i = 1; i < n; i++){
printf("Nodul nr [%d].\n\n\tAlegeti stanga(left) sau dreapta(right) pentru urmatorul nod: ", i+1);
scanf("%s", left_right);
insert(root, left_right);
}
}break;

case 2: {
print(root);
}break;

case 3: {
char denum[40];
printf("\nIntroduceti denumirea elementului cautat: ");
scanf("%s", denum);
if(search(root, denum))
printf("\nExista !!!\n");
else
 printf("\nNu exista !!!\n");

}break;

case 4: {
char denum[40];
printf("\nDenumirea elementului care doriti sa-l modificati: ");
scanf("%s", denum);
modify_a_node(root, denum);
}break;

case 5: {
printf("Numarul de noduri = %d\n", number_of_nodes(root));
}break;

case 6: {
printf("Inaltimea arborelui: %d", max_depth(root));
}break;

case 7: {
delete_tree(root);
printf("Memoria a fost eliberata !!!");
}break;

case 0: {
ult = 0;
}break;

default:
delete_tree(root);
break;
}

printf("Pentru a continua tastati ENTER !");

getchar();
getchar();
}

return 0;
}

Film.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "film.h"
void print_menu(){

printf("\n\t+==============================================+\n");
printf( "\t+ <1> Creaza Arbore. +\n");
printf( "\t+ <2> Afiseaza informatia despre arbore. +\n");
printf( "\t+ <3> Cautarea nodului in arbore. +\n");
printf( "\t+ <4> Modificare informatiei a unui nod. +\n");
printf( "\t+ <5> Determinarea numarului de noduri. +\n");
printf( "\t+ <6> Determinarea inaltimea arborelui. +\n");
printf( "\t+ <7> Eliberarea memoriei. +\n");
printf( "\t+ <0> Iesire din program. +\n");
printf( "\t+==============================================+\n\n");

Node * new_node( Film data ){

Node * root = (Node *)malloc(sizeof( Node ));

strcpy(root->data.denumirea, data.denumirea);
strcpy(root->data.tara, data.tara);
strcpy(root->data.regizor, data.regizor);

strcpy(root -> data.gen_film, data.gen_film);

root -> data.an = data.an;

root -> left = root -> right = NULL;

return (root);
}

Film input_data(){

Film a;

printf("Denumirea: ");
scanf("%s", a.denumirea);

printf("Tara: ");
scanf("%s", a.tara);

printf("regizor: ");
scanf("%s", a.regizor);

printf("Genul filmului: ");

scanf("%s", a.gen_film);

printf("an: ");
scanf("%d", &a.an);
 printf("\n\n");

return a;
}

void print(Node *root)

{
if (root != NULL)
{
print(root->left);

printf("Denumirea: %s\n", root->data.denumirea);

printf("Tara: %s\n", root->data.tara);
printf("regizor: %s\n", root->data.regizor);
printf("Genul filmului: %sd\n", root->data.gen_film);
printf("an: %d\n", root->data.an);

printf("\n-----------------------------\n");

print(root->right);
}
}

int number_of_nodes(Node *root)

{
int count = 1;
if (root->left != NULL) {
count += number_of_nodes(root->left);
}
if (root->right != NULL) {
count += number_of_nodes(root->right);
}
return count;
}

int max_depth(Node* node)

{
if (node==NULL)
return 0;
else
{

int lDepth = max_depth(node->left);

int rDepth = max_depth(node->right);

if (lDepth > rDepth)

return(lDepth+1);
else return(rDepth+1);
 }
}

Node * insert(Node* node, char* left_right)

{
if (node == NULL) return new_node(input_data());

if (!strcmp(left_right, "left"))
node->left = insert(node->left, "left");
else if (!strcmp(left_right, "right"))
node->right = insert(node->right, "right");

return node;
}

int search(Node* node, char* denum) {

if (node == NULL)
return FALSE;

if (!strcmp(node->data.denumirea, denum))
return TRUE;

int res1 = search(node->left, denum);

if(res1) return TRUE;

int res2 = search(node->right, denum);

return res2;
}

void modify_a_node(Node* root, char* denum){

if(root == NULL)
return;

if ( !strcmp(root->data.denumirea, denum)){
printf("Modifica !\n");

Film a = input_data();

strcpy(root->data.denumirea, a.denumirea);
strcpy(root->data.tara, a.tara);
strcpy(root->data.regizor, a.regizor);
strcpy(root -> data.gen_film, a.gen_film);

root -> data.an = a.an;

}
 modify_a_node(root->left, denum);
modify_a_node(root->right, denum);
}

void delete_tree(Node* node){

if (node == NULL) return;

delete_tree(node->left);
delete_tree(node->right);

free(node);
} Film.h

#ifndef FILM_H
#define FILm_H

#define TRUE 1
#define FALSE !TRUE

typedef struct {
char denumirea[40];
char tara[40];
char regizor[40];
char gen_film[40];
int an;
}Film;

typedef struct node

{
Film data;
struct node * left;
struct node * right;
}Node;

void print_menu();
Node * new_node( Film );
Film input_data();
Node * insert(Node*, char*);
void print(Node*);
int search(Node* node, char* denum);
void modify_a_node(Node*, char*);
int number_of_nodes(Node *);
int max_depth(Node*);
void delete_tree(Node*);

#endif
Rezultate :
Concluzie:
În lucrarea de laborator nr.11 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 recursivi: un fişier antet cu extensia .h, care
conține specificarea structurii de date a nodului arborelui binar şi prototipurile funcţiilor de prelucrare
ale arborelui binar oarecare, bazate pe algoritmi recursivi, un fişier cu extensia .cpp sau .c, care conține
implementările funcţiilor ,declarate în fişierul antet si funcţia mаin() pentru prelucrarea arborelui binar
oarecare cu afişarea la ecran a următorului meniu de opţiuni.