Algoritmi e Strutture Dati - Quelli di Informatica rossi e neri (Cormen... · Introduzione agli algoritmi e strutture dati 2/ed T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein

1

Introduzione agli algoritmi e strutture dati 2/ed

T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. SteinCopyright © 2005 – The McGraw-Hill Companies srl

Alberi rosso-neri

Gli alberi rosso-neri sono alberi binari di ricerca

in cui le operazioni Insert e Delete sono

opportunamente modificate in modo tale da

garantire un’altezza dell’albero h = O(log n).

A tale scopo si aggiunge un bit per ogni nodo: il

colore che può essere rosso o nero.



Oltre ad essere alberi binari di ricerca, gli alberi

rosso-neri soddisfano le seguenti proprietà:

1. ogni nodo è o rosso o nero

2. la radice è nera

3. le foglie (nil) sono tutte nere.

4. i figli di un nodo rosso sono entrambi neri

5. per ogni nodo x tutti i cammini da x alle

foglie sue discendenti contengono lo stesso

numero bh(x) di nodi neri (altezza nera).

Notare che il nodo x non è contato in bh(x)

anche se nero.

2



26

17 41

4730

38

35 39

28

21

2319

20

14

16

12 15

10

7

3

Esempio di albero rosso-nero:



26

17 41

4730

38

35 39

28

21

2319

20

14

16

12 15

10

7

3

Talvolta si usa una sentinella al posto di nil

?

3



Proprietà: Un albero rosso-nero con n nodi

interni ha altezza

h 2 log2(n+1)

Dimostrazione: Osserviamo che i nodi rossi in

un cammino dalla radice r alle foglie possono

essere al più bh(r) e quindi h 2 bh(r).

Basta quindi dimostrare che

bh(r) log2(n+1)

ossia che

n 2bh(r) - 1



Dimostriamo

n 2bh(r) - 1

per induzione sulla struttura dell’albero rosso-

nero T.

Se T = è vuoto r è una foglia, bh(r) = 0 e

n = 0 = 2bh(r) – 1

4



Sia T = (r,T1,T2) e siano r1 ed r2 le radici di T1 e

T2 e siano n1 ed n2 i numeri di nodi interni di T1

e T2. Allora

bh(r1) bh(r)-1

bh(r2) bh(r)-1

n = 1+ n1 + n2

Per ipotesi induttiva

1212121

12121

)(1)(1)(

)()( 21

rbhrbhrbh

rbhrbhn

Conseguenza: Su di un albero rosso-nero con n nodi interni le

operazioni Search, Minimum, Maximum, Successor e

Predecessor richiedono tempo O(log n).



Anche le operazioni Insert e Delete su di un

albero rosso-nero richiedono tempo O(log n) ma

siccome esse modificano l’albero possono violare

le proprietà degli alberi rosso-neri ed in tal caso

occorre ripristinare tali proprietà.

Per farlo useremo delle operazioni elementari,

dette rotazioni, che preservano la proprietà di

albero binario di ricerca.

Assumiamo venga usata la sentinella nil[T].

5



26

17 41

4730

38

35 39

28

21

2319

20

14

16

12 15

10

7

3

Talvolta si usa una sentinella al posto di nil

?



LeftRot(T,x)

y right[x]

right[x] left[y], p[left[y]] x // left[y] può essere nil[T]

p[y] p[x]

if p[x] = nil[T] then

root[T] y

else if x = left[p[x]] then

left[p[x]] y

else

right[p[x]] y

p[x] y, left[y] x

x

y

x

y

LeftRot(T,x)

RightRot(T,y)

rotazioni

6



RightRot(T,y)

x left[y]

left[y] right[x], p[right[x]] y // right[x] può essere nil[T]

p[x] p[y]

if p[y] = nil[T] then

root[T] x

else if y = left[p[y]] then

left[p[y]] x

else

right[p[y]] x

p[y] x, right[x] y

x

y

x

y

LeftRot(T,x)

RightRot(T,y)



InsertRB(T, z) // left[z] = right[z] = nil[T]

Insert(T, z)

color[z] RED

// z è rosso. L’unica violazione

// possibile delle proprietà degli alberi

// rosso-neri è che z sia radice (prop. 2)

// oppure che p[z] sia rosso (prop 4).

InsertFixUp(T, z)

Inserimento di un nuovo elemento

7



InsertFixUp(T,z)

// z è rosso e l’unica violazione

// possibile delle proprietà degli alberi

// rosso neri è che z sia radice (prop. 2)

// oppure che p[z] sia rosso (prop 4).

if z = root[T] then

// l’unica violazione delle proprietà

// degli alberi rosso neri è che root[T]

// è rosso (prop 2).

color[root[T]] BLACK // Caso 0

else

x p[z]

if color[x] = RED then

// z è rosso e l’unica violazione delle

// proprietà degli alberi rosso neri è

// che il padre x è rosso (prop 4).

// In questo caso x non è la radice.

if x = left[p[x]] then



5 9

Caso 1: y rosso (p[x] deve essere nero!!)

3

7p[x]

yx

z

5 9

3

7p[x]

yx

z

3 9

5

7p[x]

yx

z

3 9

5

7p[x]

yx

z

8



3 9

Caso 2: y nero e z figlio destro di x

5

7p[x]

yx

z

5 9

3

7p[x]

y

z' = x

x' = z

Caso 3: y nero e z figlio sinistro di x

5 9

3

7p[x]

y

z

x 5 9

3

7p[x]

y

z

x

5

9

3 7



// zio alla destra del nonno

y right[p[x]]

if color[y] = RED then // Caso 1

color[x] color[y] BLACK

color[p[x]] RED

InsertFixUp(T,p[x])

else

if z = right[x] then // Caso 2

z x, LeftRot(T,z), x p[z]

color[x] BLACK // Caso 3

color[p[x]] RED

RightRot(T,p[x])

9



Caso 1: y rosso

3 7

9

5p[x]

y x

z

3 7

9

5p[x]

y x

z

3 9

7

5p[x]

y x

z

3 9

7

5p[x]

y x

z



Caso 2: y nero e z figlio sinistro di x

3 7

9

5p[x]

y x

z

3 9

7

5p[x]

y x

z

Caso 3: y nero e z figlio destro di x

3 9

7

5p[x]

y x

z

3 9

7

5p[x]

y x

z

9

3

5 7

10



else

// zio alla sinistra del nonno

y left[p[x]]

if color[y] = RED then // Caso 1

color[x] color[y] BLACK

color[p[x]] RED

InsertFixUp(T,p[x])

else

if z = left[x] then // Caso 2

z x, RightRot(T,z ),x p[z]


color[p[x]] RED

LeftRot(T,p[x])



Complessità di InsertFixUp in funzione del

livello dz a cui si trova il nodo z.

1 Caso)2(0,2,3 Casi

)(z

z dTac

dT

Quindi InsertRB ha complessità O(log n)

dunque

)(loglog2

)( nOcnacd

adT zz

11



DeleteRB(T,z) // z nil[T]

if left[z] = nil[T] or right[z] = nil[T] then

y z //se z ha al più 1 figlio

else

y Successor(z), key[z] key[y] // se z ha 2 figli

// elimino y che ha un sottoalbero vuoto

if left[y] = nil[T] then

x right[y]

else

x left[y]

// x sottoalbero di y, l’altro è vuoto

Delete

Eliminazione di un elemento



// metto x al posto del padre y

p[x] p[y]

if p[y] = nil[T] then

root[T] x

else if y = left[p[y]] then

left[p[y]] x

else

right[p[y]] x

// Se y è rosso non ci sono violazioni

// Se y è nero l’unica violazione delle

// proprietà degli alberi rosso neri è che

// i cammini che passano per x contengono

// un nodo nero in meno.

if color[y] = BLACK then

DeleteFixUp(T,x)

12



DeleteFixUp(T,x)

// I cammini che passano per x contengono

// un nodo nero in meno.

if color[x] = RED or p[x] = nil[T] then


else

// x è nero e i cammini che passano per

// x contengono un nodo nero in meno.

if x = left[p[x]] then

// x figlio sinistro

5Caso 0: x rosso x 5x

5Caso 0: x radice x 5x



1 7

Caso 1: x nero, fratello destro w rosso e di

conseguenza padre nero

3

wx

5 9

1 7

3

wx

5 9

1

7

3

wx

5

9

13



// x figlio sinistro

w right[p[x]]

if color[w] = RED then

// x nero, fratello destro rosso

// padre nero

color[w] BLACK // Caso 1

color[p[x]] RED

LeftRot(T,p[x])

w right[p[x]]

// x nero, fratello destro nero

// padre rosso



1 7

Caso 2: x nero, fratello destro w nero con figli

neri.

3

wx

5 9

1 7

3

w

5 9

14



// x nero, fratello destro w nero

if color[left[w]] = BLACK and

color[right[w]] = BLACK then


// con entrambi i figli neri

color[w] RED // Caso 2

DeleteFixUp(T,p[x])



1 7

Caso 3: x nero, fratello destro w nero con figlio

sinistro rosso e figlio destro nero.

3

wx

5 9

1

7

w

5

9

3

x

1 7

3

wx

5 9

15



else


// ma non con entrambi i figli neri

if color[right[w]] = BLACK then


// con figlio sinistro rosso

// e figlio destro nero

color[left[w]] BLACK // Caso 3

color[w] RED

RightRot(T,w)

w right[p[x]]



1 7

Caso 4: x nero, fratello destro w nero con figlio

destro rosso.

3

wx

5

1 7

3

wx

5 9

9 1

7

3

5

9

16




// con figlio destro rosso

color[w] color[p[x]] // Caso 4

color[p[x]] BLACK

color[right[w]] BLACK

LeftRot(T,p[x])

else

// x figlio destro

// Situazione simmetrica. Basta

// scambiare left con right.



Complessità di DeleteFixUp in funzione del

livello dx a cui si trova il nodo x.

I casi 0, 3 e 4 terminano immediatamente e

dunque essi richiedono tempo costante.

Dopo aver eseguito il caso 1 viene eseguito una

sola volta il caso 2 e quindi il caso 0. Anche il

caso 1 richiede pertanto tempo costante.

Solo il caso 2 può essere ripetuto sul padre di x.

Quindi

2 Caso)1(0,1,3,4 Casi

)(x

x dTac

dT

17



Quindi DeleteRB ha complessità O(log n)

ha soluzione

)(log)1log(2)( nOcnacaddT xx

2 Caso)1(0,1,3,4 Casi

)(x

x dTac

dT

Documents

Algoritmi e Strutture Dati - Quelli di Informatica rossi e neri (Cormen... · Introduzione agli algoritmi e strutture dati 2/ed T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein