MINISTERUL EDUCAȚIEI, CULTURII ȘI CERCETĂRII

AL REPUBLICII MOLDOVA
I.P. Centrul de Excelenţă în Informatică şi Tehnologii Informaţionale

Lucrare individuală Nr 1
Disciplina: Utilizarea tehnicilor clasice de programare

Metode de optimizare combinatorială

TEMA : "Arbori binari"

A elaborat: Țuran Laura

Grupa:W-1732
Profesor: Troian Veaceslav

Chişinău, 2019
Cuprins
1. Partea teoretică ........................................................................................................... 3

1.1 Arbore binar ............................................................................................................ 3

1.2 Operaţiile de bază pe un arbore de căutare............................................................ 4

1.3 Parcurgerea arborilor ............................................................................................. 4

1.4 Program C++ Parcurgerea arborelui binar .......................................................... 5

2. Program rezolvat ........................................................................................................ 7

3.Bibliografie .................................................................................................................... 9
 1. Partea teoretică

1.1 Arbore binar

Un arbore este o structură ramificată formată dintr-un nod A (rădăcina) și un număr finit de
arbori (subarbori) ai lui A.
- orice nod din arbore este rădăcină pentru un subarbore iar orice arbore poate deveni
subarbore;
- doi subarbori pot fi în relaţie de incluziune, când un subarbore este inclus în celălalt sau de
excluziune, când nu au noduri comune.

Definiţii:
nod = punct în care se întâlnesc doi subarbori;
nivel = numărul de noduri parcurse de la rădăcină până la un nod;
rădăcină = nivel 1;
descendent = primul nod al unui subarbore;
nod terminal = nod fără descendenţi;
înălţimea unui nod = numărul maxim de niveluri;
arbore binar = arbore în care toate nodurile au 2 descendenţi;

Exemplu de arbore binar

 1.2 Operaţiile de bază pe un arbore de căutare sunt următoarele:

Operația Aloritmul
Căutare Se compara cheia cu nodul curent. Dacă este mai egală,
am găsit nodul, dacă este mai mică căutăm în subarborele
stâng, altfel căutăm în subarborele drept. Căutarea se
opreşte când nodul a fost găsit sau s-a atins baza
arborelui.
Adăugare
Se caută folosind algoritmul de căutare poziţia în arbore şi se alocă
memoria şi se face legătura cu nodul părinte.

Ștergere Se caută nodul de şters şi se şterge nodul. Subarborele drept este

avansat în locul nodului şters, iar subarborele stâng este mutat ca
fiu al celui mai mic element din subarborele drept.

1.3 Parcurgerea arborilor

Prin parcurgerea arborelui înţelegem inspectarea (vizitarea) fiecărui nod si prelucrarea

informaţiei specifice lui.
Posibilităţile de parcurgere sunt:
1. În lăţime: examinând nodurile pe niveluri, în acelasi sens.
2. În adâncime: de la rădăcină spre nodurile terminale sau invers;

În cazul parcurgerii în lăţime algoritmul conţine operaţiile:

- se examinează nodul rădăcină si se formează lista (coada) descendenţilor săi într-o anumită
ordine ( exemplu: de la stânga la dreapta) ;
- se examinează primul nod din coada de așteptare și se adaugă la coadă descendenţii săi în
ordinea stabilită;
- se repetă operaţia precedentă până când coada devine vidă.

Parcurgeri în adâncime sunt parcurgerile în preordine, inordine şi postordine.

În toate cele trei tipuri de parcurgere în adâncime se vizitează prima dată subarborele stâng
şi apoi subarborele drept, iar diferenţa constă în momentul în care se vizitează rădăcina.

Funcţiile de parcurgere pot fi scrise recursiv sau iterativ, folosind o stivă.

Parcurgerea în preordine RSD – se vizitează mai întâi rădăcina R, apoi se parcurge în

preordine subarborele stâng S şi subarborele drept D.
 Pentru arborele din figură, şirul parcurgerii RSD este: 1 2 4 5 3 6.

Parcurgerea în inordine SRD – se parcurge mai întâi în inordine suarborele stâng S, apoi
rădăcina R, apoi se parcurge în inordine subarborele drept D.
 Pentru arborele din figură, şirul parcurgerii SRD este: 4 2 5 1 6 3.

Parcurgerea în postordine SDR – se parcurg în postordine subarborele stâng S şi

subarborele drept D, iar apoi se vizitează rădăcina R.
 Pentru arborele din figură, şirul parcurgerii RSD este: 4 5 2 6 3 1.

1.4 Program C++ Parcurgerea arborelui binar

Se citesc din fisierul arbore.in de pe prima linie două numere n şi R reprezentând numărul de
noduri şi rădăcina unui arbore binar.
De pe a doua şi a treia linie se vor citi câte n elemente reprezentând rădăcinile subarborilor
stâng şi respectiv drept al fiecărui nod, sau 0 dacă nu există subarborele.
Afişaţi pe ecran şirurile parcurgerilor RSD, SRD şi SDR ale arborelui citit.
arbore.in rezultate
81 RSD: 1 2 4 5 6 3 7 8
24700000 SRD: 4 2 5 6 1 7 3 8
35806000 SDR: 4 6 5 2 7 8 3 1

43. cout<<"RSD: ";

1. #include <fstream> 44. RSD(R);
2. #include <iostream> 45. cout<<<"SRD: ";
3. using namespace std; 47. SRD(R);
4. int i,n,St[101],R,Dr[101]; 48. cout<<<"SDR: ";
5. void citire() 50. SDR(R);
6. { 51. }
7. ifstream f("arbore.in");
8. f>>n>>R;
9. for(i=1;i<=n;i++) f>>St[i];
10. for(i=1;i<=n;i++) f>>Dr[i];
11. f.close();
12. }
13. void RSD(int p)
14. {
15. if(p>0)
16.
17. { cout<<p<<' ';
18. RSD(St[p]);
19. RSD(Dr[p]);
20. }
21. }
22. void SRD(int p)
23. {
24. if(p>0) 25. {
26. SRD(St[p]);
27. cout<<p<<' ';
28. SRD(Dr[p]);
29. }
30.
31. }
32. void SDR(int p)
33. {

34. if(p>0)
35. {SDR(St[p]);
36. SDR(Dr[p]);
37. cout<<p<<' ';}
38.
39. }
40. int main()
41. {
42. citire();
 2. Program rezolvat

Cerință

Se da un arbore cu radacina cu n varfuri (n<=100) prin vectorul de tati. a) Sa se determine

daca este arbore binar si, in caz afirmativ, sa se afiseze vectorii S si D (consideram fiul stang
< fiul drept) b) Daca raspunsul de la a este negativ, sa se determine daca prin schimbarea
radacinii, arborele poate deveni binar.

Exemplul 1:
arbore.in
7
6663303
arbore.out
NU
NU

Exemplul 2:
arbore.in
6
666330
arbore.out
NU
DA

Exemplul 3:
arbore.in
6
066331
arbore.out
DA
60
00
45
00
#include <iostream> if(S[T[i]]==0)
#include <fstream> S[T[i]]=i;
using namespace std; else D[T[i]]=i;
ifstream fin("arbore.in"); }
ofstream fout("arbore.out"); for(int i=1;i<=n;i++)
fout<<S[i]<<"
"<<D[i]<<endl;
int
n,T[101],F[101],S[101],D[101],G[1 }
01];
else
{
int main()
fout<<"NU\n";
{
//cerinta b (cu vectorul
fin>>n; de grade)
for(int i=1;i<=n;i++) ok=1;
{ for(int i=1;i<=n;i++)
fin>>T[i]; if(G[i]>=4) ok=0;
F[T[i]]++;//pt a if(ok) fout<<"DA";
if(T[i]!=0)//pt b else fout<<"NU";
{ }
G[i]++; return 0;
G[T[i]]++; }
}
}
//cerinta a
int ok=1;
for(int i=1;i<=n;i++)
if(F[i]>2) ok=0;
if(ok)
{
fout<<"DA\n";
for(int i=1;i<=n;i++)
if(T[i]!=0)
{
 3.Bibliografie

http://info.mcip.ro/?cap=arbori&prob=830
http://tet.pub.ro/pages/Sda/lucrarea4.pdf
https://asandului.files.wordpress.com/2015/03/parcurgerea-arborilor-binari-c59fi-
aplicac5a3ii.pdf