Arturo Díaz Pérez

Análisis y Complejidad de Algoritmos

Arboles Rojinegros

Arturo Díaz Pérez

Análisis y Diseño de Algoritmos RedBlackTree-1

Definición
F Los árboles rojinegros son estructuras basadas en
árboles binarios balanceados.

F Un árbol rojinegro es un árbol de búsqueda binaria que

satisface las siguientes propiedades:
¬ Cada nodo o es rojo o es negro
- Cada hoja (nil) es negra
® Si un nodo es rojo, entonces, sus hijos son negros
¯ Cada camino de un nodo a cualquier descendiente tiene la
misma cantidad de nodos negros

Análisis y Diseño de Algoritmos RedBlackTree-2

Análisis y Complejidad de Algoritmos 1

Arturo Díaz Pérez

Definición
F La altura negra de un nodo x, an(x), es el número de
nodos negros que hay en cualquier camino de él a una
hoja que desciende de él.

F La altura negra de un árbol es la altura negra de su raíz.

Análisis y Diseño de Algoritmos RedBlackTree-3

Ejemplo

26

17 41

14 21 30 47

10 16 19 23 28 38 nil nil

7 12 15 nil nil 20 nil nil nil nil 35 39

3 nil nil nil nil nil nil nil nil nil nil nil

nil nil

Análisis y Diseño de Algoritmos RedBlackTree-4

Análisis y Complejidad de Algoritmos 2

Arturo Díaz Pérez

Observación
FSea A un árbol rojinegro con n nodos internos
ßSi x es un nodo en A, entonces, el subárbol con raíz
en x tiene a al menos 2an(x)-1 nodos internos.

FSea x un nodo en A, por inducción sobre an(x)

ßA) Si an(x) = 0, entonces, x es hoja y no hay nodos

en el subárbol con raíz en él.
ßPor otro lado, 2an(x)-1 = 0.

Análisis y Diseño de Algoritmos RedBlackTree-5

Observación
FB) Supongamos que an(x) > 0, x es interno y
tiene dos hijos. Es inmediato que cualquier hijo y
de x cumple con lo siguiente:

C(y) = rojo, entonces, an(y) = an(x)

C(y) = negro, entonces, an(y) = an(x) – 1

FPor hipótesis de inducción, el número de nodos

descendientes de x es al menos:
No descendientes( dere(x) ) + 1 + No_descendientes(
izq( x ) ) = 1 + 2(2an(x)-1 - 1) = 2an(x) -1
Análisis y Diseño de Algoritmos RedBlackTree-6

Análisis y Complejidad de Algoritmos 3

Arturo Díaz Pérez

Observación
FLa altura de A es a lo sumo 2log2(n +1).

FSea h la altura del árbol rojinegro.

ßAl menos la mitad de los nodos en un camino de la
raíz a una hoja , sin incluir la raíz, deben ser negros.
ßLa altura negra del árbol debe ser al menos h/2
ßPor lo anterior,
ßn = 2h/2 – 1 Y log2(n +1) = h/2 Y h = log2(n +1)

Análisis y Diseño de Algoritmos RedBlackTree-7

Observaciones
F Los árboles rojinegros son árboles de búsqueda binaria
en donde las hojas tienen valores nulos.
F Los algoritmos para árboles de búsqueda binaria se
aplican a los árboles rojinegros.
ß Al insertar una nueva llave quedará como padre de dos hojas
nulas.
F La operación de búsqueda toma un tiempo O(log n) en
el peor caso.

F Las operaciones de Inserción y Supresión son

también O(log n) pero no necesariamente mantienen
estructuras rojinegras.

Análisis y Diseño de Algoritmos RedBlackTree-8

Análisis y Complejidad de Algoritmos 4

Arturo Díaz Pérez

Rotaciones

Right_Rotate( T, x )

y x
Left_Rotate( T, x )

x γ α y

α β β γ

Análisis y Diseño de Algoritmos RedBlackTree-9

LeftRotate
LeftRotate(A; x)
{ y:=right(x);
right(x):=left(y);
if left(y) ? nil then
p(left(y)) := x;
y x
p(y) := p(x);
if p(x) = nil then
x γ α y root(A) := y
else
α β β γ if x := left(p(x)) then
left(p(x)) := y
else
right(p(x)) := y;
left(y) := x; p(x) := y }
Análisis y Diseño de Algoritmos RedBlackTree-10

Análisis y Complejidad de Algoritmos 5

Arturo Díaz Pérez

RightRotate
RighRotate(A; y)
{ x :=left(y);
left(y):= right(x);
if right(y) ? nil then
p(right(x)) := y;
y x
p(x) := p(y);
if p(y) = nil then
x γ α y root(A) := x
else
α β β γ if y := right(p(y)) then
right(p(y)) := x
else
left(p(y)) := x;
right(x) := y; p(y) := x }
Análisis y Diseño de Algoritmos RedBlackTree-11

Recorrido EntreOrden

RecorridoEntreOrden( x )
begin
if x <> nil then begin
RecorridoEntreOrden( left[x] );
writeln( x );
RecorridoEntreOrden( right[x] )
end
end;

Análisis y Diseño de Algoritmos RedBlackTree-12

Análisis y Complejidad de Algoritmos 6

Arturo Díaz Pérez

Recorrido PreOrden

RecorridoPreOrden( x )
begin
if x <> nil then begin
writeln( x );
RecorridoPreOrden( left[x] );
RecorridoPreOrden( right[x] )
end
end;

Análisis y Diseño de Algoritmos RedBlackTree-13

Recorrido PosOrden

RecorridoPosOrden( x )
begin
if x <> nil then begin
RecorridoPosOrden( left[x] );
RecorridoPosOrden( right[x] )
writeln( x );
end
end;

Análisis y Diseño de Algoritmos RedBlackTree-14

Análisis y Complejidad de Algoritmos 7

Arturo Díaz Pérez

Recorrido EntreOrden
F Las rotaciones izquierda y derecha preservan
entreórdenes. Esto es, si A es el recorrido entreorden, x
está antes que y en A y B es el recorrido entreorden
después de aplicar una rotación en x, entonces, x está
antes que y en B.

ß En efecto, consideremos situación derecha de la figura y una

rotación izquierda sobre y.
ß Se tiene α = x = β = y = γ.
ß Después de aplicar la rotación a la izquierda el orden se
preserva.

Análisis y Diseño de Algoritmos RedBlackTree-15

Inserción
F Al insertar nuevos elementos en árboles rojinegros, en
tiempo O(log n), se debe garantizar que el árbol
resultante continúe siendo rojinegro
F En los árboles rojinegros las hojas son vacías y negras
F Los nuevos elementos se colocan como padres de hojas
F Cada nuevo elemento se coloca como una estructura
del árbol binario
F Como las hojas deben ser negras, el nodo que contiene
la llave a insertarse se colorea como rojo
ß No se aumenta la altura negra del árbol
F La única propiedad que puede violarse es la referente al
color del padre del nodo que se ha insertado
Análisis y Diseño de Algoritmos RedBlackTree-16

Análisis y Complejidad de Algoritmos 8

Arturo Díaz Pérez

InserciónRN
InserciónRN( A; x )
{ InserciónABB( A; x );
C(x) := red;
p := p(x);
while x ? root(A) ^ C(p) = red do {
if p = left (p(p(x)) then {
u := right(p(p(x));
if C(u) = red then {
1) C(p) := C(u) := black;
C(p(p(x)) := red;
x:= p(p(x)); p := p(x)
} else {
...
Análisis y Diseño de Algoritmos RedBlackTree-17

InserciónRN (cont.)
...
if x = right(p) then {
2) x := p;
LeftRotate( A; x ); p := p(x)
};
3) C(p(x)) := black;
C(p(p(x)) := red;
RightRotate( A; p(p(x)) )
}
} else {
(código simétrico intercambiando “left” y “right” )
};
};
C(root(A)) := black
};
Análisis y Diseño de Algoritmos RedBlackTree-18

Análisis y Complejidad de Algoritmos 9

Arturo Díaz Pérez

InserciónRN( A, x ): Caso 1

a)
C C

A D A D

α B x δ ε α B δ ε

β γ β γ

Análisis y Diseño de Algoritmos RedBlackTree-19

InserciónRN( A, x ): Caso 1
b)

C C

B D B D

A γ δ ε A γ δ ε

α β α β

Si x rojo y ambos padre y tío rojo, repintamos a estos últimos de negro y al

padre de ambos de rojo. Como A es RN, ese abuelo era negro. Al hacer los
cambios, alturas negras no se modifican. Trasladamos la dificultad en x, a su
abuelo padre(padre) y reiteramos ciclo principal.
Análisis y Diseño de Algoritmos RedBlackTree-20

Análisis y Complejidad de Algoritmos 10

Arturo Díaz Pérez

InserciónRN( A, x ): Casos 2 y 3

C C B
Caso 2 Caso 3
A δ B δ x A C

α B x x A γ α β γ δ

β γ α β

Análisis y Diseño de Algoritmos RedBlackTree-21

Casos 2 y 3
F Caso 2: x y padre rojo mas tío negro y, x hijo derecho de
padre.
ß La rotación izquierda sobre padre reduce el caso al de 3). No se
afecta a las alturas negras.

F Caso 3: x y padre rojo mas tío es negro y, x es hijo

izquierdo de padre
ß Repintar a padre negro, al abuelo rojo y rotación derecha sobre
el abuelo.
ß Las alturas negras no se modifican y la posición del abuelo
quedaría negra, con ambos hijos rojo.
ß El ciclo principal no se repetirá más.

Análisis y Diseño de Algoritmos RedBlackTree-22

Análisis y Complejidad de Algoritmos 11

Arturo Díaz Pérez

InserciónRN( A, x )

11 11

2 14 2 14

1 7 15 Caso 1 1 7 x 15

5 8 5 8

4 x 4

Análisis y Diseño de Algoritmos RedBlackTree-23

InserciónRN( A, x )

11 11

2 14 7 14

1 7 x 15 Caso 2 x 2 8 15

5 8 1 5

4 4

Análisis y Diseño de Algoritmos RedBlackTree-24

Análisis y Complejidad de Algoritmos 12

Arturo Díaz Pérez

InserciónRN( A, x )

11
7

7 14 Caso 3
2 11

x 2 8 15
1 5 8 14

1 5
4 15

Análisis y Diseño de Algoritmos RedBlackTree-25

InserciónRN( A, x )
11 11

2 14 2 14

1 7 15 Caso 1 1 7 x 15

5 8 5 8

4 x 4
Caso 2

7 11

2 11 7 14

1 5 8 14 Caso 3 x 2 8 15

4 15 1 5

Análisis y Diseño de Algoritmos RedBlackTree-26

Análisis y Complejidad de Algoritmos 13

Arturo Díaz Pérez

Supresión
F Coincide con la operación de supresión en los árboles
de búsqueda binaria
F Sin embargo, es necesario mantener la estructura de los
árboles rojinegros
F Para evitar repeticiones se introduce vigía, nil(A), el cual
representa las hojas del árbol rojinegro
F Si el nodo suprimido y fuese rojo, entonces, las alturas
negras no cambian y, en tal caso, termina
F Si el nodo suprimido y fuese negro, entonces, las ramas
que pasen por y tienen un nodo negro menos, lo que
viola la condición de los árboles rojinegros. En este
caso es necesario ajustar colores.

Análisis y Diseño de Algoritmos RedBlackTree-27

SupresiónABB( A, x ): 0 ó 1 hijo

15 15
a)
5 |6 5 |6

3 12 20 3 12 20

10 13 x 18 23 10 18 23

6 6

7 7

Análisis y Diseño de Algoritmos RedBlackTree-28

Análisis y Complejidad de Algoritmos 14

Arturo Díaz Pérez

SupresiónABB( A, x ): 0 ó 1 hijo

15 15
b)
5 |6 5 20
x

3 12 20 3 12 18 23

10 13 18 23 10 13

6 6

7 7

Análisis y Diseño de Algoritmos RedBlackTree-29

SupresiónABB( A, x ): 2 hijos

c) 15
15 15
6
x 5 |6
5 |6 6 |6

3 12 20
3 12 20 3 12 20

10 13 18 23
10 18 23 10 18 23

6
7 7

Análisis y Diseño de Algoritmos RedBlackTree-30

Análisis y Complejidad de Algoritmos 15

Arturo Díaz Pérez

SupresionRN
SupresionRN( A, z )
{
if (left(z) = nil(A)) or (right(z) = nil(A))
then y := z;
else y := SucesorABB(z);
if left(y) ? nil(A)
then x := left( y );
else x := right( y );
p(x) := p(y);
if p(y) = nil
then root( A ) := x;
else
if y = left( p(y) )
then left( p(y) ) := x
else right( p(y) ) := x;
if y ? z then key(z) = key( y );
if C(y) = black then AjustarSupresionRN( A, x )
Análisis y Diseño de Algoritmos RedBlackTree-31
}

AjustarSupresionRN
AjustarSupresionRN( A, x )
{ /* Ciclo principal */
while x ? root(A) and C(x) = black do {
if x = left( p(x) ) then {
w := right( p(x) );
if C(w) = red then {
1) C(w) := black;
C(p(x)) := red;
LeftRotate( A, p(x) );
w := right( p(x) )
};
if ambos hijos de w son negros then {
2) C(w) := red; x := p(x)
} else {
RedBlackTree-32
Análisis y Diseño de Algoritmos
...

Análisis y Complejidad de Algoritmos 16

Arturo Díaz Pérez

AjustarSupresionRN (cont.)
if C(right(w)) = black then {
3) C( left(w) ) := black; C(w) := red;
RightRotate( A, w );
w := right( p(x) )
};
4) C(w) := C(p(x)); C(p(x) := black;
C(right(w)) := black;
LeftRotate( A, p(x) );
x := root( A )
}
} else
{ código simétrico intercambiando “left” y “right” }
};
C(x) := black
RedBlackTree-33
};
Análisis y Diseño de Algoritmos

SupresiónRN( A, x ): Caso 1

a)
B Caso 1 D

x A D w B E

α β C E x A C new w ε ζ
c c

γ δ ε ζ α β γ δ

x negro y hermano rojo. A hermano se le pinta negro, a padre rojo y

rotar a la izquierda. Se obtiene configuración como en 2).
Al ejecutarse 2) se concluirá el ciclo principal pues x actual roja.

Análisis y Diseño de Algoritmos RedBlackTree-34

Análisis y Complejidad de Algoritmos 17

Arturo Díaz Pérez

SupresiónRN( A, x ): Caso 2
b)
B c new x B c

x A D w Caso 2 A D

α β C E α β C E

γ δ ε ζ γ δ ε ζ

x y hermano negros, así como ambos hijos de hermano. A hermano se le

pinta rojo y se fuerza a padre a llevar marca negra de “acarreo”

Análisis y Diseño de Algoritmos RedBlackTree-35

SupresiónRN( A, x ): Caso 3
c) c
B c B

x A D w Caso 3 x A C new w

α β C E α β γ D

γ δ ε ζ δ E

ε ζ

x y hermano negros, el hijo derecho de hermano negro y el izquierdo rojo.

Al hijo izquierdo de hermano se le pinta negro y a hermano de rojo.
Rotar a la derecha para obtener la configuración en 4).

Análisis y Diseño de Algoritmos RedBlackTree-36

Análisis y Complejidad de Algoritmos 18

Arturo Díaz Pérez

SupresiónRN( A, x ): Caso 4
d)
B c D c

x A D w x B E w
Caso 4

α β C c’ E A C c’ ε ζ

new x = root(A)
γ δ ε ζ α β γ δ

x y hermano negros, el hijo derecho de hermano rojo y el izquierdo negro.

A padre se le pinta negro, a hermano del que tenía padre y al hijo derecho
de hermano también negro.
Rotar a la izquierda para equilibrar alturas negras.

Análisis y Diseño de Algoritmos RedBlackTree-37

Conclusiones
F Las operaciones de inserción y supresión recorren un
árbol rojinegro a lo más dos veces.

F Por tanto, su complejidad en tiempo para el peor caso

está acotada por O( log n )

F ¿Cómo se podría plantear el análisis del caso

promedio?

F Cómo se puede analizar el mejor caso?

Análisis y Diseño de Algoritmos RedBlackTree-38

Análisis y Complejidad de Algoritmos 19