Sunteți pe pagina 1din 5

Săptămâna 9 – Curs – Structuri de date și algoritmi – 27.11.

2013

Arbori
- definiție, caracterizare
- reprezentări, parcurgeri
- arborele parțial de cost minim
- Codul lui Prufer
- arbori binari

1) Definiție:

G=(V,E) – graf (neorientat)


Cu urm. prop: este conex și aciclic
Orice graf conex și aciclic se numește arbore.
Propoziție: Dacă G=(V,E) este arbore și card(V)=|V|=n atunci |E|=n-1 !!!
Demonstrație: prin inducție după n
Se observă că pentru n=1 sau n=2 trivial.
Presupunem că afirmația este adevărată pentru orice arbore cu n noduri. Fie un
arbore A=(X,Y) un arbore cu n+1 noduri (|X|=n+1).
Afirmație: Există x din X astfel încât d(x)=1 (gradul lui x=1).
Presupunem prin absurd că oricare ar fi z din X, d(z)>1 => A are cicluri (contradicție)

x
Există y din X astfel încât {x,y} din Y.
Fie A’=(X\{x},Y\{{x,y}})
A’ este conex.
A’ este aciclic (altfel A ar fi ciclic, dar A e arbore)
A’ arbore => (din ipoteza inducției) are (n-1) muchii
Deci |Y|=n ((n-1) muchii + muchia {x,y})

TEOREMĂ: (de caracterizare)


Fie G=(V,E) graf cu |V|=n. Următoarele afirmații sunt echivalente (U.A.E).
1. G este arbore
2. G este aciclic cu (n-1) muchii
3. G este conex cu (n-1) muchii
4. G este aciclic maximal (adică, orice muchie am adăuga s-ar forma un ciclu).
5. G este conex minimal (adică, orice muchie am scoate, își pierde conexitatea).
6. Orice 2 noduri din V sunt unite de un singur lanț(unic lanț)

1
Săptămâna 9 – Curs – Structuri de date și algoritmi – 27.11.2013

Demonstrații:
1) => 2) Trivial
2) => 3) G este aciclic. Dem că G este conex. Presupunem că G nu este conex.
Adaugăm muchii lui G până când G devine conex. Fie G’ noul graf. Acum G’ este
conex (dar și aciclic) => G’ este arbore cu mai mult de (n-1) muchii (contradicție,
trebuie să aibă exact (n-1) muchii).
3) => 4) Presupunem prin absurd că G este ciclic (nu este aciclic). Eliminăm muchii
din G până devine aciclic DAR păstrând conexitatea. Am obținut un arbore dar cu
mai puțin de (n-1) muchii – contradicție) => G este aciclic.
G este maximal (în raport cu aciclitatea) – Dacă mai adăugăm o muchie, obținem
un ciclu.

Fie o muchie nouă {x,y}. Deoarece G este conex există un lanț de la x la y (x-y lanț).
=> avem un ciclu.
4) => 5) Presupunem că G nu este conex => exista două noduri x și y care nu sunt
legate (unite) – adică nu există lanț între x și y.
Adăugăm muchia {x,y} => avem ciclu – CONTRADICȚIE . => G conex minimal
5) => 6) Între orice două noduri avem un lanț (pt. că avem conexitatea din 5). )
Unicitatea lanțului rezultă din faptul că G este conex minimal!
6) => 1) Existența lanțului implică conexitatea, și unicitatea lanțului implică
aciclitatea.

PAUZĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂĂ
GATA PAUZA 

2) Reprezentare:
- orice reprezentare a grafului
- putem folosi o reprezentare cu 2 vectori sau cu liste
1. un vector FIU. FIU[i] = ,,primul” nod descendent al lui i

j1 j2 j3 j4
2. un vector FRATE. FRATE[i] = următorul descendent al nodului ce are pe i ca
descendent direct
Ex. FRATE[j1]=j2 ; FRATE[j2]=j3; FRATE[j3]=j4; FRATE[j4]=0;

3 4
2

2
Săptămâna 9 – Curs – Structuri de date și algoritmi – 27.11.2013

6 7 8 9
5
13
10 11 12

14

NULL
NULL
3 4

7
etc.
Parcurgeri: A – preordine sau A- postordine
A – preordine; Se parcurge rădăcina dupa care se parcurg toți subarborii cu rădăcinile
descendenții direcți ai rădăcinii. Exemplu: 1,2,5,10,11,14,12,3,6,7,13,4,8,9.
procedure A-preordine(j);
vizitare(j); k:=j;
if (FIU[k] != 0 )
A-preordine(FIU[k]);
endif
k:= FIU[k];
if (k!=0)
While (FRATE[k]!=0)
A-preordine(FRATE[k]);
K:=FRATE[K];
endwhile
endif
endprocedure

A – postordine; Se parcurg toți subarborii cu rădăcinile descendenți direct ai rădăcinii, după


care se parcurge rădăcina.
Ex: 10, 14, 11, 12, 5, 2, 6, 13, 7, 3, 8, 9, 4, 1.

procedure A-postordine(j);
k:=j;

3
Săptămâna 9 – Curs – Structuri de date și algoritmi – 27.11.2013

if (k.↑FIU != NULL)
A-postordine(k. ↑FIU);
endif;
k:=k. ↑FIU;
if (k!= NULL)
While (k. ↑FRATE!=NULL)
A-postordine(k. ↑FRATE);
k:= k. ↑FRATE;
endwhile
endif
vizitare(k.INFO);
endprocedure.

TATA[i]=j; i este fiul lui j.

Fie o mulțime de numere {x1,x2,…,xp}.


Punem x1 rădăcină.

x2 x3 x4
1 2 3 n
...

Reuniunea de arbori
Reprezentarea mulțimilor:
TATA[RAD]= -k ; k este numărul de elemente al mulțimii;
TATA[i]=jș Procedura de reuniune:
procedure Reuniune(a,b);
k:=TATA[a]+TATA[b];
if (TATA[a]>=TATA[b])
TATA[a]=b;
TATA[b]=k;
else
TATA[b]=a;
TATA[a]=k;
endif
endprocedure

Propoziție: Arborele asociat unei mulțimi de n elemente are cel mult Гlog 2 n˥.

Demonstrație: Inducție după n.


Pentru n=2 . Evident.
Pentru < n -> r
Reuniune între A și B
|A B|=n

4
Săptămâna 9 – Curs – Structuri de date și algoritmi – 27.11.2013

|A|<=n/2
Numărul de nivele al arborelui pentru A este: Гlog 2 n˥. (parte întreagă superioară)
Numărul de nivele în A B = max(log 2 nA+1,log2nB) =
Гlog 2 n/2˥+1 <= Гlog 2 n˥
<= log2(n-1) + 2 <=log2n + 1

procedure Apartenență(x,y) // x parametrul


k:=x;
while (TATA[k]>0)
k:=TATA[k];
endwhile
y:=k;
endprocedure

Avem graful ponderat G=(V,E,w)

3
4 1
2 1 3

9 5 1
2

Arborele parțial de cost minim


Algoritmul lui KRUSKAL (in timp O(n*logn))