Árboles Rojo - Negro

Tecnológico de Costa Rica
Jeffrey Camareno
Sergio Sánchez
Xavier Vega
2013

• Un árbol rojo-negro es un tipo abstracto de datos.
Concretamente, es un árbol binario de búsqueda
equilibrado, una estructura de datos utilizada
en informática y ciencias de la computación.
• Es complejo, pero tiene un buen peor caso de tiempo de
ejecución para sus operaciones y es eficiente en la
práctica. Puede buscar, insertar y borrar en un tiempo
O(log n), donde n es el número de elementos del árbol.

• La estructura original fue creada por Rudolf
Bayer en 1972, que le dio el nombre de “árbolesB binarios simétricos”, pero tomó su nombre moderno en
un trabajo de Leo J. Guibas y Robert
Sedgewick realizado en 1978.

• Los árboles rojo-negro ofrecen un peor
caso con tiempo garantizado para la
inserción, el borrado y la búsqueda. No es
esto únicamente lo que los hace valiosos
en aplicaciones sensibles al tiempo como
las aplicaciones en tiempo real, sino que
además son apreciados para la
construcción de bloques en otras
estructuras de datos que garantizan un
peor caso. Por ejemplo, muchas
estructuras de datos usadas en geometría
computacional pueden basarse en árboles

• Los árboles rojo-negro son
particularmente valiosos
en programación funcional, donde son
una de las estructuras de
datos persistentes más comúnmente
utilizadas en la construcción de arrays
asociativos y conjuntos que pueden
retener versiones previas tras
mutaciones. La versión persistente del
árbol rojo-negro requiere un espacio
O(log n) para cada inserción o

• Un árbol rojo-negro es un árbol binario de búsqueda en
el que cada nodo tiene un atributo de color cuyo valor
es rojo o negro. En adelante, se dice que un nodo es
rojo o negro haciendo referencia a dicho atributo.

• Además de los requisitos impuestos a los árboles
binarios de búsqueda convencionales, se deben
satisfacer las siguientes reglas para tener un árbol rojonegro válido:
• Todo nodo es o bien rojo o bien negro.
• La raíz es negra.
• Todas las hojas (NIL) son negras.
• Todo nodo rojo debe tener dos nodos hijos negros.
• Cada camino desde un nodo dado a sus hojas
descendientes contiene el mismo número de nodos
negros.

• Estas reglas producen una características producen una
regla crucial para los árboles rojo-negro: el camino más
largo desde la raíz hasta una hoja no es más largo que
dos veces el camino más corto desde la raíz a una hoja.
El resultado es que dicho árbol está aproximadamente
equilibrado.

•
•
•
•

Todo nodo es o bien rojo o bien negro.
La raíz es negra.
Todas las hojas son negras.
Todo nodo rojo debe tener dos nodos hijos
negros.
• Cada camino desde un nodo dado a sus
hojas descendientes contiene el mismo
número de nodos negros

• Rotación
• Búsqueda
• Inserción
• Eliminación

• Para conservar las propiedades que debe
cumplir todo árbol rojo-negro, en ciertos casos de
la inserción y la eliminación será necesario
reestructurar el árbol, si bien no debe perderse la
ordenación relativa de los nodos. Para ello, se
llevan a cabo una o varias rotaciones, que no
son más que reestructuraciones en las
relaciones padre-hijo-tío-nieto.

• Las rotaciones que se consideran a continuación son
simples; sin embargo, también se dan las rotaciones
dobles.
• En las imágenes pueden verse de forma simplificada
cómo se llevan a cabo las rotaciones simples hacia la
izquierda y hacia la derecha en cualquier árbol binario de
búsqueda, en particular en cualquier árbol rojo-negro.
Podemos ver también la implementación en C de dichas
operaciones.

void rotar_izda(struct node *p) {
struct node **aux=&raiz;
if(p->padre!=NULL && p->padre->dcho==p) aux=&(p->padre->dcho);
else if(p->padre!=NULL && p->padre->izdo==p) aux=&(p->padre>izdo);
*aux=p->dcho; (*aux)->padre=p->padre;
p->padre=*aux;
p->dcho=(*aux)->izdo; (*aux)->izdo=p;
if(p->dcho!=NULL) p->dcho->padre=p;
}

void rotar_dcha(struct node *p) {
struct node **aux=&raiz;
if(p->padre!=NULL && p->padre->dcho==p)
aux=&(p->padre->dcho);
else if(p->padre!=NULL && p->padre->izdo==p)
aux=&(p->padre->izdo);
*aux=p->izdo; (*aux)->padre=p->padre;
p->padre=*aux; p->izdo=(*aux)->dcho;
(*aux)->dcho=p;
if(p->izdo!=NULL) p->izdo->padre=p;
}

• La búsqueda consiste acceder a la raíz del árbol y
comparar su valor con el valor buscado. Si el elemento a
localizar coincide con el de la raíz, la búsqueda ha
concluido con éxito. Si el elemento es menor, se busca
en el subárbol izquierdo; si es mayor, en el derecho. Si se
alcanza un nodo hoja y el elemento no ha sido
encontrado se supone que no existe en el árbol. Cabe
destacar que la búsqueda en este tipo de árboles es muy
eficiente y representa una función logarítmica. La
búsqueda de un elemento en un ABB (Árbol Binario de
Búsqueda) en general, y en un árbol rojo-negro en
particular, se puede realizar de dos formas: iterativa y
recursiva.

• TipoDato buscar_abb_iterativo(Abb a, TipoValor
buscado){
• TipoDato e = NULL; Abb p = a;
• while (!estaVacio(p) && (p->valor != buscado) ){
• if (buscado < p->valor) p = p->izquierda;
• if (p->valor < buscado) p = p->derecha; }
• if (!estaVacio(p)) e = copiaDato(p->dato); return e; }

• La inserción comienza añadiendo el nodo como lo
haríamos en un árbol binario de búsqueda convencional
y pintándolo de rojo. Lo que sucede después depende
del color de otros nodos cercanos. El término tío
nodo será usado para referenciar al hermano del padre
de un nodo, como en los árboles familiares humanos.
Conviene notar que:
• La propiedad 3 (Todas las hojas, incluyendo las nulas,
son negras) siempre se cumple.
• La propiedad 4 (Ambos hijos de cada nodo rojo son
negros) está amenazada solo por añadir un nodo rojo,
por repintar un nodo negro de color rojo o por una
rotación.
• La propiedad 5 (Todos los caminos desde un nodo dado
hasta sus nodos hojas contiene el mismo número de
nodos negros) está amenazada solo por repintar un nodo

• Al contrario de lo que sucede en otros árboles como
puede ser el Árbol AVL, en cada inserción se realiza un
máximo de una rotación, ya sea simple o doble. Por otra
parte, se asegura un tiempo de re-coloración máximo
de por cada inserción.
• Nota: En los esquemas que acompañan a los algoritmos,
la etiqueta N será utilizada por el nodo que está siendo
insertado, P para los padres del nodo N, G para los
abuelos del nodo N, y Upara los tíos del nodo N.
Notamos que los roles y etiquetas de los nodos están
intercambiados entre algunos casos, pero en cada caso,
toda etiqueta continúa representando el mismo nodo que
representaba al comienzo del caso. Cualquier color
mostrado en el diagrama está o bien supuesto en el caso
o implicado por dichas suposiciones.
Los nodos tío y abuelo pueden ser encontrados por las
siguientes funciones:

• En un árbol binario de búsqueda normal, cuando se borra un nodo con
dos nodos internos como hijos, tomamos el máximo elemento del
subárbol izquierdo o el mínimo del subárbol derecho, y movemos su
valor al nodo que es borrado. Borramos entonces el nodo del que
copiábamos el valor que debe tener menos de dos nodos no hojas por
hijos. Copiar un valor no viola ninguna de las propiedades rojo-negro y
reduce el problema de borrar en general al de borrar un nodo con
como mucho un hijo no hoja. No importa si este nodo es el nodo que
queríamos originalmente borrar o el nodo del que copiamos el valor.
• Resumiendo, podemos asumir que borramos un nodo con como
mucho un hijo no hoja (si solo tiene nodos hojas por hijos, tomaremos
uno de ellos como su hijo). Si borramos un nodo rojo, podemos
simplemente reemplazarlo con su hijo, que debe ser negro. Todos los
caminos hasta el nodo borrado simplemente pasarán a través de un
nodo rojo menos, y ambos nodos, el padre del borrado y el hijo, han
de ser negros, así que las propiedades 3 (todas las hojas, incluyendo
las nulas, son negras) y 4 (los dos hijos de cada nodo rojo son negros)
se mantienen. Otro caso simple es cuando el nodo borrado es negro y
su hijo es rojo. Simplemente eliminar un nodo negro podría romper las
propiedades 4 (los dos hijos de cada nodo rojo son negros) y 5 (todos
los caminos desde un nodo dado hasta sus hojas contienen el mismo
número de nodos negros), pero si repintamos su hijo de negro, ambas
propiedades quedan preservadas.

• El caso complejo es cuando el nodo que va a ser
borrado y su hijo son negros. Empezamos por
reemplazar el nodo que va a ser borrado con su hijo.
Llamaremos a este hijo (en su nueva posición) N, y su
hermano (el otro hijo de su nuevo padre) S. En los
diagramas de debajo, usaremos P para el nuevo padre
de N, SL para el hijo izquierdo de S, y SR para el nuevo
hijo derecho de S (se puede mostrar que S no puede ser
una hoja).
• Nota: Entre algunos casos cambiamos roles y etiquetas
de los nodos, pero en cada caso, toda etiqueta sigue
representando al mismo nodo que representaba al
comienzo del caso. Cualquier color mostrado en el
diagrama es o bien supuesto en su caso o bien
implicado por dichas suposiciones. El blanco representa
un color desconocido (o bien rojo o bien negro).El
cumplimiento de estas reglas en un árbol con n nodos,

• Caso 1: N es la nueva raíz. En este caso, hemos
acabado. Borramos un nodo negro de cada camino y la
nueva raíz es negra, así las propiedades se cumplen.
Una posible implementación en el lenguaje de
programación C sería la siguiente:
void eliminar_caso1(struct node *n) {
if (n->padre!= NULL)
eliminar_caso2(n); }

• Caso 2: S es rojo. En este caso invertimos los colores
de P y S, por lo que rotamos a la izquierda P, pasando S a
ser el abuelo de N. Nótese que P tiene que ser negro al
tener un hijo rojo. Aunque todos los caminos tienen
todavía el mismo número de nodos negros, ahoraN tiene
un hermano negro y un padre rojo, así que podemos
proceder a al paso 4, 5 o 6 (este nuevo hermano es negro
porque éste era uno de los hijos de S, que es rojo). En
casos posteriores, reetiquetaremos el nuevo hermano
de N como S. Aquí podemos ver una implementación:
void eliminar_caso2(struct node *n) { struct node *hm =
hermano(n);
if (hm->color == ROJO) { n->padre->color = ROJO;
hm->color = NEGRO;
if (n == n->padre->izdo) rotar_izda(n->padre);
else rotar_dcha(n->padre); }
eliminar_caso3(n); }

• Caso 3: P, S y los hijos de S son negros. En este caso,
simplemente cambiamos S a rojo. El resultado es que
todos los caminos a través de S, precisamente aquellos
que no pasan por N, tienen un nodo negro menos. El
hecho de borrar el padre original de N haciendo que todos
los caminos que pasan por N tengan un nodo negro
menos nivela el árbol. Sin embargo, todos los caminos a
través de P tienen ahora un nodo negro menos que los
caminos que no pasan por P, así que la propiedad 5 aún
no se cumple (todos los caminos desde cualquier nodo a
su nodo hijo contienen el mismo número de nodos
negros). Para corregir esto, hacemos el proceso de
reequilibrio en P, empezando en el caso 1. Su
implementación en C:
• void eliminar_caso3(struct node *n) { struct node *hm =
hermano_menor(n); if ((n->padre->color == NEGRO) &&
(hm->color == NEGRO) && (hm->izdo->color == NEGRO)
&& (hm->dcho->color == NEGRO)) { hm->color = ROJO;

• Caso 4: S y los hijos de éste son negros, pero P es rojo.
En este caso, simplemente intercambiamos los colores
de S y P. Esto no afecta al número de nodos negros en los
caminos que no van a través de S, pero añade uno al
número de nodos negros a los caminos que van a través
de N, compensando así el borrado del nodo negro en
dichos caminos. Si lo implementamos en C, quedaría:
struct node *hm = hermano_menor(n);
if ((n->padre->color == ROJO) && (hm->color == NEGRO)
&& (hm->izdo->color == NEGRO) && (hm->dcho->color ==
NEGRO)) {
hm->color = ROJO;
n->padre->color = NEGRO; }
else eliminar_caso5(n); }

• Caso 5: S es negro, su hijo izquierdo es rojo, el derecho
es negro, y N es el hijo izquierdo de su padre. En este
caso rotamos a la derecha S, así su hijo izquierdo se
convierte en su padre y en el hermano de N. Entonces
intercambiamos los colores de S y su nuevo padre. Todos
los caminos tienen aún el mismo número de nodos
negros, pero ahora N tiene un hermano negro cuyo hijo
derecho es rojo, así que caemos en el caso 6. Ni Nni su
padre son afectados por esta transformación (de nuevo,
por el caso 6, reetiquetamos el nuevo hermano
de N como S). He aquí la implementación en C:
void eliminar_caso5(struct node *n) { struct node *hm =
hermano(n); if ((n == n->padre->izdo) && (hm->color ==
NEGRO) && (hm->izdo->color == ROJO) && (hm->dcho>color == NEGRO)) { hm->color = ROJO; hm->izdo->color
= NEGRO; rotar_dcha(hm); } else if ((n == n->padre>dcho) && (hm->color == NEGRO) && (hm->dcho->color
== ROJO) && (hm->izdo->color == NEGRO)) { hm->color
= ROJO; hm->dcho->color = NEGRO; rotar_izda(hm); }

• Caso 6: S es negro, su hijo derecho es rojo, y N es el hijo izquierdo
de P, su padre. En este caso rotamos a la izquierda P, así que S se
convierte en el padre de P y éste en el hijo derecho de S. Entonces
intercambiamos los colores de P y S, y ponemos el hijo derecho
de Sen negro. El subárbol aún tiene el mismo color que su raíz, así
que las propiedades 4 (los hijos de todo nodo rojo son negros) y 5
(todos los caminos desde cualquier nodo a sus nodos hoja contienen
el mismo número de nodos negros) se verifican. Sin embargo, N tiene
ahora un antecesor negro mas: o bien P se ha convertido en negro, o
bien era negro y S se ha añadido como un abuelo negro. De este
modo, los caminos que pasan por N pasan por un nodo negro mas.
Mientras tanto, si un camino no pasa por N, entonces hay dos
posibilidades:
• Éste pasa a través del nuevo hermano de N. Entonces, éste debe
pasar por S y P, al igual que antes, y tienen sólo que intercambiar los
colores. Así los caminos contienen el mismo número de nodos negros.
• Éste pasa por el nuevo tío de N, el hijo derecho de S. Éste
anteriormente pasaba por S, su padre y su hijo derecho, pero ahora
sólo pasa por S, el cual ha tomado el color de su anterior padre, y por
su hijo derecho, el cual ha cambiado de rojo a negro. El efecto final es
que este camino va por el mismo número de nodos negros.
• De cualquier forma, el número de nodos negros en dichos caminos no
cambia. De este modo, hemos restablecido las propiedades 4 (los
hijos de todo nodo rojo son negros) y 5 (todos los caminos desde
cualquier nodo a sus nodos hoja contienen el mismo número de nodos
negros). El nodo blanco en diagrama puede ser rojo o negro, pero

•
•
•
•
•
•
•
•
•
•
•

struct node *hm = hermano(n);
hm->color = n->padre->color; n->padre->color = NEGRO;
if (n == n->padre->izdo) {
/* * Aquí, hm->dcho->color == ROJO.
*/ hm->dcho->color = NEGRO;
rotar_izda(n->padre); } else {
/* * Aquí, hm->izdo->color == ROJO.
*/ hm->izdo->color = NEGRO;
rotar_dcha(n->padre);
}}

• Un árbol rojo-negro que contiene n nodos internos tiene una altura de
O(log(n)).
• Hagamos los siguientes apuntes sobre notación:
• H(v) = altura del árbol cuya raíz es el nodo v.
• bh(v) = número de nodos negros (sin contar v si es negro)
desde v hasta cualquier hoja del subárbol (llamado altura-negra).
•
Lema: Un subárbol enraizado al nodo v tiene al menos nodos
internos.
• Demostración del lema (por inducción sobre la altura):
• Caso base: h(v)=0 Si v tiene altura cero entonces debe ser árbol
vacío, por tanto bh(v)=0. Luego:
• Hipótesis de Inducción: si v es tal que h(v) = k y contiene nodos
internos, veamos que esto implica que tal que h() = k+1
contiene nodos internos.
• Si tiene h() > 0 entonces es un nodo interno. Como éste tiene dos
hijos que tienen altura-negra, o bh() o bh()-1 (dependiendo si es rojo
o negro). Por la hipótesis de inducción cada hijo tiene al

• Usando este lema podemos mostrar que la altura del árbol
es algorítmica. Puesto que al menos la mitad de los nodos
en cualquier camino desde la raíz hasta una hoja negra
(propiedad 4 de un árbol rojo-negro), la altura-negra de la
raíz es al menos h(raíz)/2. Por el lema tenemos que:
• Por tanto, la altura de la raíz es O(log(n)).

http://www.ece.uc.edu/~franco/C321/html/RedBlac
k/

http://www.youtube.com/watch?v=vDHFF4wjW
YU

• http://arbolescplusplus.wordpress.com/category/uncateg
orized/arboles-rojo-y-negro/
• http://www.infor.uva.es/~cvaca/asigs/doceda/rojonegro.p
df
• http://es.wikipedia.org/wiki/%C3%81rbol_rojo-negro

Árboles Rojo - Negro

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Árboles Rojo - Negro

Similar a Árboles Rojo - Negro (20)

Último

Último (20)

Árboles Rojo - Negro