Introducción
En este trabajo, se estará llevando a cabo la
explicación de dos tipos de forma de balanceo
de árboles binarios, para una búsqueda
equilibrada; siendo estructuras de datos
usadas en informática y ciencias
computacionales. Para el caso de balanceo de
árboles binarios Red-Black Tree y arboles
binarios Scapegoat Tree.
En el proceso, estaremos comparando estas
dos estructuras de datos, dando a conocer sus
propiedades, sus usos. Conociendo también,
su implementación en lenguajes de
programación como Java.
1. Marco teórico
1.1. Historia Red-Black Tree
La estructura original del árbol Red-Black,
fue creada por Rudolf Bayer en 1972, que le
dio el nombre de “árboles-B binarios
simétricos”, pero tomó su nombre moderno
en un trabajo de Leo J. Guibas y Robert
Sedgewick realizado en 1978.[1]
1.2. Historia Scapegoat
El término de Scapegoat, que significa en
español chivo expiatorio, se debe a Igal
Galperin y Ronal L.Rivest, que se definen y
analizan estos árboles.
Sin embargo, la misma estructura se
descubrió anteriormente por Arne
Andersson , que los llamó árboles generales
equilibradas ya que pueden tener cualquier
forma siempre que su altura es pequeña.
1.3. Propiedades
1.3.1. Propiedades de Red-Black Tree
Una de las características del árbol Red-Black
Tree, es que sus nodos son identificados por
los colores Rojo y Negro. Y entre sus
principales propiedades encontramos:
 Todo nodo puede llegar a ser negro o
rojo
 La raíz siempre es negra
 Todas las hojas de los nodos, son
nulos.
 Todo nodo rojo debe de tener dos
nodos hijos negro
 Ningún nodo rojo debe de tener como
padre o raíz un nodo rojo, es decir, no
debe de haber una secuencia sucesiva
de nodos rojos.
Entre estas propiedades, se produce una regla
crucial: el camino más largo desde la raíz
hasta una hoja  no es más largo que dos veces
el camino más cortó desde la raíz a una hoja.
Dándonos como respuesta, que este árbol se
aproxima a estará equilibrado.[1]
Al igual que otras formas de equilibrio de
árboles, en esta también contamos con
operaciones básicas como insertar, borrar y
buscar valores.
1.3.2. Propiedades de Scapegoat Tree
Entre las propiedades que podremos
encontrar en los arboles Scapegoat, es que
estos se puede mantener equilibrado por
operaciones de reconstrucciones
parciales[2]. En un proceso de
reconstrucción parcial, el árbol es destruido y
reconstruido en un subárbol balanceado.
Al igual que el árbol Red-Black Tree, este
posee nodo que apuntan a nodos izquierdos
y derecho, de la misma forma, llamados
hojas.
Una gran diferencia, es que ya no se guía por
tener reglas para el color de los nodos,
simplemente sigue el orden establecido para
asignar datos a los hojas de los nodos.
Tiene una gran ventaja; y es que, es que no
necesita almacenar información adicional en
cada nodo. Esto ahorrando grandes
cantidades de espacio, lo que es muy útil 2. Algoritmo
cuando el espacio es limitado.
2.1. Diagrama de flujo Red-Black Tree
A comparación de el árbol Red-Black, este
almacena el color de cada nodo y si 2.2. Diagrama de flujo Scapegoat Tree
comparamos el árbol AVL, este almacena la
altura de cada nodo.[3]

1.4. Usos

1.4.1. Red-Black Tree

Los arboles Red-Black nos sirven muy bien
cuando tenemos un peor caso con tiempo
garantizado para métodos como inserción,
borrado y búsqueda. Siendo muy útiles en
aplicaciones que dependen bastante del
tiempo como aplicaciones en tiempo real,
además de ser muy apreciados en
construcciones de bloques en otras estructuras
de datos que por lo general son de peor caso.
Un ejemplo de estructura que usan arboles
Red-Black son aquellas usadas para
geometría computacional y últimamente muy
utilizada para el desarrollo de Videojuegos,
como para el mezclado de animaciones, o
para indexar el espacio[4].

1.4.2. Usos de Scapegoat Tree

Este tipo de árbol, es muy utilizado para

aplicaciones que su principal función es la de
agregar y buscar datos, ya que en esta tarea,
es muy eficaz al realizarla[3].
3. Ejemplo de demostración

3.1. Ejemplo de Red-Black Tree

Para realizar un ejemplo, estaremos
ingresando números a un árbol Red-Black
para poder entender como este interactúa.
Lo primero por hacer es ingresar un número;
en este caso ingresaremos el número 8:

Siempre que ingresemos un valor, este vendrá

de color rojo. Siendo que es nuestro primero
valor, este se convierte en nuestra raíz; pero
ya nos dice las reglas de árboles Red-Black
que la raíz siempre será de color negro,
entonces:

Para seguir insertaremos el numero 6

Y ya que 6 es menor a 8, significa que la

izquierda de 8 es 6.

Por el momento, el color del 6 no cambiara,

ya que, para ser de color Rojo, debe de que su
raíz o padre, sea de color Negro, y que sus
hijos no sean de color Rojo, por lo que en el
momento, conserva el color Rojo. Ahora
ingresaremos el número 7.
Como 7 es menor a 8, deberá de buscar algún Procedemos después a hacer una rotación
espacio por la izquierda del número 8, o por derecha con respecto a 7 y 8.
su hoja izquierda.

Como ya habíamos dicho, la raíz principal

debe de ser negra, por lo que se cambia el
Pero se ha encontrado que su hoja izquierda color de 7 a Negro, además del 8 a Rojo.
está ocupada, lo que significa que ahora
Este proceso se va a realizar para muchos
deberá compararse con esta hoja para saber
eventos, pero se realiza a sub-árboles que se
hacia qué lado u hoja debe de asignarse; en
entabla alguna relación con los datos
este caso, 7 es mayor a 6, por lo que la hoja
alterados. Para dar una mejor explicación
derecha de 6 será 7.
ingresaremos en número 3:

Este proceso de ubicación del valor, se hace Seguimos el proceso de buscar a que hoja se
de la misma forma para todos los casos, debe de ubicar.
comparándose con las hojas que se encuentre
y posicionándose a un lado de esta hoja.
Pero hemos encontrado un problema, el árbol
se ha desbalanceado y en el momento
incumple una regla de los arboles Red-Tree,
el cual dice que ningún nodo rojo debe de
tener como padre o raíz un nodo rojo. Este caso es de lo que más se presentara. Para
Antes de asignar el verdadero color del nodo, este, vemos que ya hay una sucesión de nodos
primero se balancea el árbol: rojos, por lo que debemos de cambiar su
color, conservando el color de la raíz, aunque
Hacemos una rotación izquierda de valores esta se verá afectada en el cambio de color.
para 7 y 6
Cambiamos el color de los parientes de
número 3, por lo que número 6 cambió de
color al igual que número 7, nuestra raíz.
Pero, la raíz siempre debe de ser de color
negro, por lo cual:
Es posible tener nodos negros sucesivos. De
este modo podemos continuar insertando
valores. A continuación se mostrara más
ingresos de datos para intentar resolver
alguna duda.
Aquí ya ingresamos suficiente valores para
demostrar un balanceo de árboles internos.
Para balancearlo debemos de dar un giro
izquierdo entre 8 y 11, de este modo
cambiaremos la raíz, además del color de 2
nodos. Siempre estar pendiente a la altura que
llevan estos árboles.
Como vemos, el nodo 7 se convirtió de Rojo
sin alterar sus hojas, y nodo 11 se convirtió
en Negro sin alterar tampoco sus hojas. Este
proceso fue gracias a que es posible tener
varios nodos negros consecutivos, y por
supuesto, el cambio del color Rojo en el
momento adecuando.
Para el método de eliminación, es muy fácil,
ya que solo deberemos de cambiar el dato del
nodo por el valor menor de su hoja derecha,
si no existe será el valor mayor de su hoja
izquierda; siempre teniendo en cuenta que se
debe de balancear el árbol si se toda la hoja
izquierda. Y para lo último, eliminar el nodo
en el que se encontró el nuevo valor. Siendo
así, eliminaremos el número 7:
Ya encontrada la posición de 7, procedemos a
buscar el número menor por su hoja derecha.
En este caso 8, por lo que tomaremos su
valor, eliminamos el nodo y asignamos el
valor al nodo del número 7; quedándonos:
Uno de los casos que se podrían considerar
extremos, como eliminar la raíz principal, se
vuelve una tarea sencilla:
Entonces, nuestro valor seria el menor por su
rama derecha, en este caso, 12.
Pero no debemos olvidar el balanceo de
árboles mediante el proceso.
3.2. Ejemplo de Scapegoat Tree
Para realizar un ejemplo, estaremos
ingresando números a un árbol Scapegoat
para poder entender como interactúa este con
nuestros datos.
Este tipo de árbol sigue con las mismas
estructuras que otros árboles, cuando se busca
la ubicación en la que se va a colocar el nodo,
se deberá de comparar los nodos y decidir a
qué lado se deberá de colocar el nodo,
debemos de tener en claro que todos los
nodos tienen la característica que poseen una
hoja izquierda y una hoja derecha.
Para este caso utilizaremos los numero del 9
al 1, de este modo nos aseguramos de cubrir
uno de los peores casos que se puedan tomar.
Para iniciar tomaremos el número 9, y como
al iniciar el árbol, este se encuentra vacío,
este tendrá como raíz el número 9.
Nuestro siguiente número es 8, por lo que
este vendrá a situarse en la hoja izquierda del
nodo número 9.

Ya que la convertimos en una lista simple

ordenada, deberemos de iniciar el proceso de
El siguiente número seria 7, por lo que este
balanceo desde la raíz del subárbol que
deberá situarse en la hoja izquierda del nodo
estamos procesando; en este caso, el nodo 7.
8.
Para este proceso, tomaremos el primer valor
de la lista, el nodo 7 y este se convertirá en la
hoja izquierda del siguiente nodo.

En este momento, ya se encuentra el árbol

desbalanceado. Para poder balancear el árbol,
se debe de convertir el subárbol
desbalanceado en una lista simple.

Nuestro siguiente valor a procesar seria el

nodo 9, pero este ya no tiene más nodos, por
lo que se dejara aquí.
Para convertir el subárbol en una lista simple,
tomaremos nuestra la raíz de nuestro subárbol Ingresaremos 6.
e iremos creando nuestra lista de modo
ordenado con respecto a sus hojas. Si el nodo
que estamos analizando, en este caso 9, posee
hoja izquierda, significa posiblemente posea
uno o más menores a él. Por lo que la hoja
derecha de nuestra hoja izquierda del nodo 9,
será nuestro mismo nodo 9 y la hoja derecha
Este no ha desbalanceado el árbol, por lo que
de nuestro nodo 9 será vacío, ya que las
podemos ingresar el siguiente número, 5.
estamos convirtiendo en una lista simple.

Y 8 posee hoja izquierda, por lo que se

deberá hacer el mismo proceso.
En este momento, ya se ha desbalanceado el
árbol, pero nuestro subárbol se encuentra en
el nodo 7; por lo que, debemos de hacer el
proceso de convertir el subárbol en una lista
simple ordenada.
Ya que es una lista ordenada, procedemos a
convertirla en subárboles pequeños.
En este momento se encuentra balanceado;
así que, seguiremos ingresando valores.
Ahora el número 4.
Se ha desbalanceado desde el subárbol del
nodo 8. Por lo que deberemos de convertirla
en una lista simple ordenada desde este
punto.
Para el primer cambio debemos de entender
que la hoja derecha de la hoja izquierda del
nodo 8 es el mayor de la hoja izquierda de 8.
Por lo que, la hoja izquierda del nodo 9 será
esta.
Ya se ha convertido en una lista simple
ordenada, por lo que nuestro siguiente paso es
crear subárboles pequeños desde el inicio de
esta lista simple.
Como podemos ver, el momento que se hizo
el cambio, fue cuando el nodo que estamos
analizando no tenía hoja izquierda.
Después de hacer estos pequeños subárboles,
nos queda hacer un balanceado de árboles.
El primer nodo que estaremos analizando,
desde luego, será la raíz, el número 5. En
este momento su siguiente que es 7, se
volverá raíz de 5, y la hoja izquierda de 7, el
número 6, se volver ahora la hoja derecha de
5. Este proceso se llevaría igual para la hoja
derecha del nodo 7.
Ya ordenados, seguiremos el ejemplo
ingresando los números 3 2 y 1.
Con el número 3, se ha desbalanceado desde
el subárbol del nodo número 7. Por lo que se
deberá volver una lista simple ordenada desde
este punto.
Y procedemos a construir los sub-arboles
internos de esta lista.
 lista simple ordenada desde este, se continua
con la construcción de sub-árboles para luego
hacer un balance.

Y ahora balanceamos, desde la raíz.

Ahora con el número 2.

Balanceamos el árbol.

En este no se ha desbalanceado. Seguimos

con el número 1.

Y terminaríamos con el árbol balanceado.

En este se a desbalanceado, pero desde

nuestro nodo número 3; por lo que se hará la
4. Implementación en lenguaje de p.right =
programación buildBalanced(a, 0, ns);
p.right.parent
= p;
4.1. Red-Black Tree en Java }
else
4.2. Scopegoat Tree en Java {
// Método para insertar un p.left =
elemento buildBalanced(a, 0, ns);
public boolean add(int p.left.parent =
x) p;
{ }
// Método para hacer pista }
básica mantenimiento de inserción // Método para empacar
de profundidad en una matriz
NodeSGT u = new protected int
NodeSGT(x); packIntoArray(NodeSGT u,
int d = NodeSGT[] a, int i)
addWithDepth(u); {
if (d > log32(q)) if (u == null)
{ {
//profundidad return i;
superado, encontrar chivos }
expiatorios i =
NodeSGT w = packIntoArray(u.left, a, i);
u.parent; a[i++] = u;
while return
(3*size(w) <= 2*size(w.parent)) packIntoArray(u.right, a, i);
w = }
w.parent; // Método para
construir nodos equilibradas
rebuild(w.parent); protected NodeSGT
} buildBalanced(NodeSGT[] a, int i,
return d >= 0; int ns)
} {
// Método para if (ns == 0)
reconstruir el árbol de u nodo return null;
protected void int m = ns / 2;
rebuild(NodeSGT u) a[i + m].left =
{ buildBalanced(a, i, m);
int ns = size(u); if (a[i + m].left !
NodeSGT p = = null)
u.parent; a[i +
NodeSGT[] a = new m].left.parent = a[i + m];
NodeSGT[ns]; a[i + m].right =
packIntoArray(u, a, buildBalanced(a, i + m + 1, ns -
0); m - 1);
if (p == null) if (a[i +
{ m].right != null)
root = a[i +
buildBalanced(a, 0, ns); m].right.parent = a[i + m];
root.parent = return a[i + m];
null; }
} // Método para añadir
else if (p.right == la profundidad
u) public int
{ addWithDepth(NodeSGT u)
 { q++;
NodeSGT w = root; return d;
if (w == null)
{ 4.3. }
root = u;
n++;
q++;
5. Análisis de la complejidad del
return 0; algoritmo
}
boolean done = 5.1. Complejidad Red-Back Tree
false;
int d = 0;
do { En el análisis de la complejidad del
algoritmo, nos fundamentamos en la
if comprensión de que un árbol Red-Black se
(u.getValue() < w.getValue())
{ debe de cumplir que su altura h es máximo:
if (w.left
== null) h ≤ 2 log ( n+ 1 )
{
w.left Como función de la altura negra de un nodo
= u; de un nodo negro bh ( x ), está definida como
el número de nodos negros en cualquiera de
u.parent = w; las trayectorias desde x hasta una hoja, sin
done =
contar el nodo x.
true;
} Para dar un ejemplo, se probara que un
else
{ subárbol que contiene por lo menos 2bh( x)−1
w = de nodos internos, iniciando desde un nodo x .
w.left;
} Para proceder, debemos de entender que
} nuestro nodo x , su altura como nodo en
else if
función de una altura negra es igual a 0, en
(u.getValue() > w.getValue())
{ caso de ser un nodo externo. Por lo que:
if (w.right
== null) bh ( x )=0
{
w.right 2bh(0) −1=20−1=0
= u;
En caso de que nuestro nodo sea una hoja,
u.parent = w; entonces, significa que tenemos una altura de
done = por lo menos 1, si se encuentra balanceado:
true;
} bh ( x )=1
w =
w.right; 2bh(1) −1=21−1=1
}
else Cuando x tiene una alturah , los nodos de sus
{ hijos, poseerá una altura h−1. Para cuando
return -1;
} uno de los hijos de x es rojo, este tendrá una
d++; altura negra de:bh( x ) al igual que su padre.
} while (!done); Pero al ser un hijo de nodo negro, este tendrá
n++;
una altura de bh ( x )−1 y esto es debido a que
no se cuenta el nodo negro.
Siendo así, consideramos que los subárboles
de los hijos de x , deben de tener por lo menos
2bh ( x )−1−1 de nodos internos.
Para conocer la cantidad de nodos internos de
subárbol que comienza en x , sumaremos los
nodos internos de aquellos subárboles hijos,
agregando también el nodo interno x :
n ≥ ( 2bh (x )−1 −1 ) +(2¿¿ bh ( x )−1−1)+1=¿ ¿
( 2bh ( x )−1−1 )−1=2bh ( x )−1−1
De esto se concluye que: al menos la mitad de
los nodos de un trayecto de un nodo hasta las
hojas deben de ser nodos de color Negro.
Ya que h es la altura de un árbol, que
comienza en x , tendríamos que:
h que puede tratarse de la raíz del árbol, como
bh ( x )=
2
Reemplazamos en la expresión para n ,
función de bh( x )
h
bh ( x )−1 2
n≥2 −1 ≥ 2 −1
Despejamosh ,
h ≤ 2 log ( n+ 1 )
Si dejamos de lado las constantes, nos
quedaría un algoritmo de orden logarítmico.
[5]
Θ(log ( n ))
5.2. Complejidad Scapegoat Tree
Para conocer la complejidad de este árbol,
primero nos centraremos en el método de
agregar o de inserción. Al igual que con
árboles de búsqueda binaria, la búsqueda de
un nodo se encuentra a través de una
búsqueda binaria y estos procesos poseen
una complejidad de:
Θ ( log 2 ( n ) )
Para esto, nuestro árbol debe de saber si
tiene que equilibrarse en algún momento;
este proceso lo hace de modo que cuando se
ingresa un nuevo nodo a través de la
ascendencia de este nodo por el árbol, hasta
el primer nodo de cuyo subárbol esta
desequilibrado. Para subir por el árbol, para
encontrar la cabeza del subárbol
desequilibrado, o como se suele apodar,
nuestro chivo expiatorio; se llevara a cabo un
tiempo de:
α Θ ( log 2 ( n ) )
Este proceso puede llevar tiempo, siendo un
analizas de distinta perspectivas, debido a
puede tratarse de un subárbol en lo más
profundo del árbol.
En el último caso, sería mucho más rápido
dando un proceso de re-equilibrio:
Θ ( n ) Θ ( log 2 ( n ))
Es debido a que, antes de una reconstrucción
del árbol, la raíz del subárbol ya se había
dado ciertas inserciones que no causaron un
re-equilibrio.
En este caso, se da una ecuación según las
inserciones.
Ω (|i|)|i|iΘ ( log 2 ( n ) ) Θ (|i|)
Ω (|i|)∗Θ ( log 2 ( n ) ) + Θ(|i|)
=Θ( log 2 (n))
Ω(|i|)
6. Conclusiones
 Posee una forma semejante a la
estructura de árboles binarios AVL
 Su método de eliminar elementos
resulta ser rápido.
  Al menos la mitad de los nodos de un
trayecto de un nodo hasta las hojas
deben ser de color Negro.
 Puede resultar más demorar en
procesos de búsqueda.

7. Bibliografía
[1] R. Sedgewick, “Left-leaning Red-
Black Trees,” Public Talk, p. 8, 2008.
[2] “8. Los árboles Scapegoat.” [Online].
Available:
http://opendatastructures.org/ods-
java/8_Scapegoat_Trees.html.
[Accessed: 05-Apr-2017].
[3] “Árbol cabeza de turco | Brillante
Matemáticas y Ciencias Wiki.”
[Online]. Available:
https://brilliant.org/wiki/scapegoat-
tree/. [Accessed: 05-Apr-2017].
[4] “Desarrollo de Videojuegos: Tecnicas
Avanzadas - Francisco Moya, Carlos
Gonzalez, David Villa, EspaCursos -
Google Libros.” [Online]. Available:
https://books.google.com.co/books?
id=JmDABAAAQBAJ&pg=PA59&lp
g=PA59&dq=aplicaciones+que+usan
+red-
black+tree&source=bl&ots=AZHD6
W5RRZ&sig=vd0Me7GDovPxwmxB
67MIhO83CqI&hl=es&sa=X&ved=0a
hUKEwjHzYi584PTAhVCJCYKHY
HMDCAQ6AEIJjAC#v=onepage&q=
aplicaciones que u. [Accessed: 01-
Apr-2017].
[5] P. Leopoldo and S. Bijit, “Árboles
coloreados. Red black.,” 2008.