Arborele binar

DEF. Arborele binar este arborele cu rădăcină în care un nod are cel mult doi fii.

Definiția recursivă:
 (Baza:) Arborele fără niciun nod este un arbore binar.
 (Pasul recursiv:) Fie A și B doi arbori binari, iar x un nod. Atunci arborele care îl are pe X ca
rădăcină, pe A ca subarbore stâng și pe B ca subarbore drept este un arbore binar.

În aceasta situatie se poate vorbi (pentru un arbore nevid) de cei doi subarbori (stâng si drept) ai
unui arbore.

Proprietăţi arbore binar:

1) Un arbore binar cu înălţimea h (h=lungimea maximă a unui lanț elementar de la rădăcină la o
frumză) și n noduri are:
 cel mult 2h frunze pe ultimul nivel (rădăcina este pe nivelul 0).
 cel mult 2h+1 -1 noduri (20+21+...+2h = 2h+1-1).

 n<= 2h+1-1  n+1<=2h+1  log2(n+1)<=h+1  h>=log2(n+1)-1

2) Dacă a este numărul de FRUNZE într-un arbore binar iar c este numărul nodurilor care au
exact 2 descendenţi, atunci a=c+1
Un arbore binar strict este un arbore binar în care:
- fiecare nivel k, diferit de ultimul nivel, are 2k noduri
- fiecare nod are 0 fii (e frunză) sau 2 fii ( e neterminal)

 Are un numar impar de noduri.

Arbore binar plin

Se consideră un arbore cu n
noduri și cu înălțimea h.
Def. Un arbore binar plin este un arbore binar cu proprietatea că
pe fiecare nivel K se află exact 2K noduri, K{0,1,…,h},

Proprietăţi:

1) n = 2h+1-1
2) h= log2(n+1)-1
3) Dacă are K noduri terminale, toate situate pe acelasi nivel atunci are in total 2k-1 noduri.
Dem. Fiind un arbore binar strict cu toate frunzele pe acelasi nivel, rezultă că toate nodurile
neterminale au exact 2 fii. Fie h inaltimea arborelui=> pe fiecare nivel i sunt 2 i noduri iar pe
nivelul h sunt k=2h noduri (doar Frunze) => in total sunt 20+21+...+2h = 2h+1-1=2k-1
noduri

Arborii binari compleţi sunt arbori binari care se obţin dintr-un arbore binar plin prin
eliminarea din dreapta către stânga (sau invers) a unor noduri de pe ultimul nivel.

Proprietăţi:

1. toate frunzele arborelui se află pe ultimele 2 niveluri

2. 2h ≤ n < 2h+1 , n numărul total de noduri din arbore
3. h=[log2(n)]
Arbori de sortare

Definitie. Un arbore de sortare este un arbore binar în care pentru orice vârf informaţia ataşată
vârfului este mai mare decât informaţiile vârfurilor din subarborele stâng şi mai mică decât
informaţiile vârfurilor din subarborele drept.

Observaţie.
Parcurgerea în inordine a unui arbore de căutare produce informaţiile ataşate vârfurilor în ordine
crescătoare.

Arbori binari echilibraţi - sunt arbori binari în care, pentru orice nod, numărul nodurilor
din subarborele drept şi numărul nodurilor din subarborele stâng diferă cu cel mult o unitate.

Arbori binari degenerați - sunt arbori binari cu n vârfuri dispuse pe n niveluri.

 Reprezentare arbori binari
1) cu ajutorul vectorului Tată.

T=(0,1,1,2,2,5,3)

nod 1 2 3 4 5 6 7
tata 0 1 1 2 2 5 3

2) Arborele binar se poate memora (reprezenta/implementa) cu ajutorul fiilor, prin utilizarea a doi
vectori S şi D.

S[x]=Fiu Stânga[x] dacă există, altfel 0

D[x]=Fiu Dreapta[x] dacă există, altfel 0

nod 1 2 3 4 5 6 7
S 2 4 0 0 6 0 0
D 3 5 7 0 0 0 0

3) Prin alocare dinamică (Heap)

Structura nodului:

 leg_st= Fiu stanga sau NULL; leg_dr= Fiu dreapta sau NULL
 adresa listei= adresa nodului rădăcină
 frunzele au leg_st=leg_dr=NULL
 în câmpul info se memorează numărul nodului sau informația asociată
 4. Arborii binari compleți / plini se pot reprezenta cu ajutoul unui vector cu n componente
(n=nr noduri):

 v[1]=radacina (nivel 0),

 v[2], v[3] nodurile de pe nivelul 1,

 v[4],v[5],v[6]v[7] de pe nivelul 2, de la stanga la dreapta,…

 v=(1,2,3,4,5)

Parcurgeri arbori
Doua tipuri de parcurgere a unui arbore sunt folosite frecvent: parcurgerea în latime si
parcurgerea în înaltime.

Pentru arborii binari, trei tipuri de parcurgere în adâncime sunt uzuale: parcurgerea în preordine
(RSD), în inordine (SRD) si în postordine (SDR). Prescurtarile au urmatoarea semnificatie:

Parcurgere arbori binari

a) Parcurgerea în preordine sau traversarea RSD:
1) se vizitează rădăcina
2) se vizitează subarborele stâng
3) se vizitează subarborele drept
b) Parcurgerea în inordine sau traversarea SRD:
1) se vizitează subarborele stâng
2) se vizitează rădăcina
3) se vizitează subarborele drept
c) Parcurgerea în postordine sau traversarea SDR:
1) se vizitează subarborele stâng
2) se vizitează subarborele drept
3) se vizitează rădăcina
1. Implementare parcurgere arbore binar cu radacina dat prin vectorii fiu_st si
fiu_dr.
fisier arbbin.in
7 n=nr noduri
1 1=rad-radacina
2 3 fiu-stanga fiu-dreapta
4 5 unde n-avem fii punem 0
0 7
0 0
6 0
0 0
0 0

#include <iostream>
#include <fstream> //parcurgere in inordine SRD
void SRD(int k)
{ if (s[k]) SRD(s[k]);
using namespace std; cout<<k<<" ";
if (d[k]) SRD(d[k]);
int s[20],d[20],n,rad; }
ifstream f("arbbin.in"); //parcurgere in postordine SDR
void SDR(int k)
void citeste() { if (s[k]) SDR(s[k]);
{ int i; if (d[k]) SDR(d[k]);
f>>n>>rad; cout<<k<<" ";
for(i=1;i<=n;i++) }
f>>s[i]>>d[i];} int main()
{citeste();
//parcurgere in preordine RSD cout<<"\nPreordine RSD:";
RSD(rad);
void RSD(int k) cout<<"\nInordine SRD:";
{ cout<<k<<" "; SRD(rad);
if (s[k]!=0) RSD(s[k]); cout<<"\nPostordine SDR:";
if (d[k]) RSD(d[k]); SDR(rad);return 0;
} }
2. Implementare creare și parcurgere arbore binar cu rădăcină.
Etichetele nodurilor sunt date in preordine
Fisierul conține 0 pentru absenta fiu.
La afisare:
- un subarbore vid se noteazã cu '-';
- un nod terminal se reprezintã prin informaþia sa utilã (deci, subarborii vizi ai
frunzelor nu sunt marcați);
- un nod neterminal se reprezintã astfel :
- un nod cu un fiu stâng : a(b,-);
- un nod cu un fiu drept : a(-,c);
- un nod cu doi fii : a(b,c).

Fișier arbdin.in
1 2 4 0 0 5 0 0 3 6 0 0 7 0 8 0 0

Iesire:
1(2(4,5),3(6,7(-,8)))

#include <iostream>
#include <fstream> void afisare(ref *p)
using namespace std; { if (!p) cout<<"-";
struct ref else
{int inf; ref *st,*dr;}; { cout<<p->inf;
ref *rad; if (!frunza(p))
ifstream in("arbdin.in"); { cout<<"("; afisare(p->st);
cout<<","; afisare(p->dr);
ref* generare(ref *p) cout<<")";
{int x; in>>x; } }}
if (x!=0)
{p=new ref; p->inf=x; int main()
p->st=generare(p->st); p- { rad=generare(rad);
>dr=generare(p->dr);} cout<<endl<<endl;
else p=NULL; afisare(rad);
return p;} cout<<endl<<endl;
return 0;
int frunza(ref *p) }
{ return (!p->st)&&(!p->dr);}

http://ler.is..ielu.ir//~ea//pr/setee/./t/2004/he/p/o/toe-/rb.ihea