RB-insert ( T , z ) // z.left = z.right = T.nil Insert ( T , z ) z.color = RED

Inserimento di un nuovo elemento RB-insert(T, z) // z.left = z.right = T.nil Insert(T, z) z.color= RED // z è rosso. L’unica violazione // possibile delle proprietà degli alberi // rosso-neri è che zsia radice (prop. 2) // oppure che z.p sia rosso (prop. 4) RB-Insert-Fixup(T, z)

z.p.p 7 z.p y 5 9 z.p.p 7 z 3 z.p y 5 9 z 3 RB-Insert-Fixup(T, z) whilez.p.color == RED // violata la proprietà 4 ifz.p == z.p.p.left// l’altro caso è simmetrico y = z.p.p.right ify.color == RED // Caso 1 z.p.color = y.color = BLACK z.p.p.color = RED z = z.p.p

z.p.p 7 z.p y 5 9 z.p.p z 7 3 z.p y 3 9 z 5 elseifz == z.p.right// Caso 2 z = z.p Left-Rotate(T, z)

z.p.p 7 z.p.p z.p y 7 5 5 9 z.p y   5 9 z  3 7 3 z      3 9   // zfiglio sinistro // Caso 3 z.p.color = BLACK z.p.p.color = RED Right-Rotate(T, z.p.p) else // simmetrico con righteleftscambiati // alla fine del ciclo l’unica proprietà violata può // essere soltanto la 2 T.root.color = BLACK // Caso 0

Complessità. Ogni volta che si ripete il ciclo while il puntatore z risale di due posizioni. Quindi il ciclo può essere ripetuto al più h volte e la complessità di RB-Insert-Fixup è O(log n). Quindi RB-Insert ha complessità O(log n).

Cancellazione di un elemento Rb-Delete(T, z) // z ≠T.nil ifz.left == T.nilorz.right == T.nil y = z else y = Successor(z), z.key =y.key // eliminoyche ha almeno un sottoalbero vuoto ify.left ==T.nil x = y.right else x = y.left // xsottoalbero di y, l’altro è sicuramente vuoto

// mettoxal posto del padre y x.p =y.p ify.p == T.nil T.root =x elseify == y.p.left y.p.left =x else y.p.right =x // Seyè rosso non ci sono violazioni ify.color == BLACK // Seyera nero l’unica violazione delle // proprietà degli alberi rosso neri è che // i cammini che passano per xcontengano // un nodo nero in meno RB-Delete-Fixup(T, x)

3 7 x w 1 7 3 9    x w  5 9 1 5 3     x     w 1 7   5 9     RB-Delete-Fixup(T, x) whilex ≠ T.rootandx.color == BLACK ifx == x.p.left// l’altro caso è simmetrico w = x.p.right ifw.color == RED // Caso 1 w.color = BLACK x.p.color = RED Left-Rotate(T, x.p) w = x.p.right

3 x w 1 7   5 9 3   w   1 7   5 9     // il fratellowè nero ifw.left.color == BLACK andw.right.color == BLACK // Caso 2 w.color = RED x = x.p

3 x w 1 7 3 3   5 9 x w 1 7 x w 1 5       5 9   7      9    elseifw.right.color == BLACK // Caso 3 w.left.color = BLACK w.color = RED Right-Rotate(T, w) w = x.p.right

3 x w 1 7   5 9 3 7   x w   1 7 3 9     5 9 1 5         // Caso 4 w.color = x.p.color x.p.color = w.right.color = BLACK Left-Rotate(T, x.p) x = T.root else// simmetrico con righteleftscambiati

Caso 0: xrosso x 5 x Caso 0: xradice 5 x x 5 // quando termina il ciclo o xè la radice // oppurexè rosso x.color = BLACK // Caso 0 5

Complessità di RB-Delete-Fixup. Con i casi 0, 3 e 4 il ciclo while termina immediatamente e dunque essi richiedono tempo costante. Dopo aver eseguito il caso 1 viene eseguito una sola volta il caso 2 e poi uno dei casi 0, 3 o 4. Quindi anche il caso 1 richiede tempo costante. Solo il caso 2 può essere ripetuto sul padre di x. Quindi il ciclo può essere ripetuto al più h volte e la complessità è O(log n).

Come aumentare gli alberi La soluzione di alcuni problemi algoritmici richiede la progettazione di una struttura dati appropriata. Spesso una tale struttura si può ottenere aumentando strutture dati note. Supponiamo ci serva una struttura dati su cui poter eseguire, oltre alle operazioni previste per gli alberi di ricerca, anche l’operazione di statistica ordinale Select(k) che ritorna il nodo con la chiave k-esima.

Un modo per farlo è aumentare gli alberi rosso-neri aggiungendo a ciascun nodo x un ulteriore campo intero x.size in cui memorizzare il numero di nodi interni del sottoalbero di radice x.

19 2 41 7 26 20 21 4 47 1 ? 0 14 7 16 2 38 3 28 1 12 1 7 2 23 1 15 1 10 4 3 1 30 5 39 1 17 12 35 1 20 1 key size

Osservazione. Se usiamo la sentinella T.nil e poniamo T.nil.size= 0allora per ogni nodo interno x vale l’equazione x.size = 1 + x.left.size + x.right.size

Possiamo realizzare facilmente Select: Select(x, k) // 1 ≤k ≤ x.size // Trova il nodo con chiave k-esima // nel sottoalbero di radice x i = 1 + x.left.size ifi== k returnx elseifi> k returnSelect(x.left, k) else returnSelect(x.right, k-i)

Possiamo realizzare facilmente anche l’operazione inversa Rank(x) che trova la posizione k della chiave di x nella sequenza ordinata delle chiavi dell’albero Rank(T, x) // Trova la posizione kdella chiave di x i = 1 + x.left.size y = x whiley.p≠ T.nil ify == y.p.right i = i+ 1 + y.p.left.size y = y.p returni

Naturalmente dobbiamo modificare RB-Insert e RB-Deleteper mantenere aggiornato il campo size dei nodi RB-Insert(T, z) // z.left = z.right = T.nil Insert(T, z) z.color =RED RB-Insert-Fixup(T, z) RB-Insert ha due fasi. Nella prima si scende dalla radice fino ad una foglia che viene quindi sostituita con il nuovo nodo. Nella seconda si ripristinano le proprietà violate.

Per la prima fase basta mettere 1 nel campo sizedel nuovo nodo z e aumentare di 1 il campo size di tutti i nodi incontrati scendendo verso la foglia che verrà sostituita con z.

Insert(T, z) z.size= 1 // istruzione aggiunta x = T.root, y = T.nil whilex ≠ T.nil x.size =x.size + 1 // istruzione aggiunta y = x ifz.key < y.key x = y.left elsex = y.right z.p =y ify == T.nil T.root =z elseifkey[z] < key[y] x.left =z elsex.right =z

      Nella seconda fase le modifiche alla struttura sono dovute alle rotazioni. x y Left-Rotate(T, x) x y Right-Rotate(T, y) I campi size dei nodi diversi da x e y rimangono invariati. Basta quindi ricalcolare i campi size dei due nodi x e y usando la relazione: x.size = 1 + x.left.size + x.right.size

x y   LeftRot(T,x)     y x Left-Rotate(T, x) y = x.right x.right = y.left, y.left.p= x y.p = x.p ifx.p == T.nil T.root = y elseifx == x.p.left x.p.left = y else x.p.right = y x.p = y, y.left = x y.size = x.size// istruzioni aggiunte x.size = 1 + x.left.size + x.right.size

RB-insert ( T , z ) // z.left = z.right = T.nil Insert ( T , z ) z.color = RED