Programacin III, Gua 7

Facultad : Ingeniera
Escuela : Computacin
Asignatura: Programacin III

Tema: RBOLES ROJO - NEGRO.

Objetivos
Implementar la estructura de rboles B y rboles Rojo Negro, utilizando C#.

Introduccin
Un rbol rojo negro es un tipo abstracto de datos, concretamente es un rbol binario de
bsqueda equilibrado, una estructura de datos utilizada en informtica y ciencias de la
computacin. Puede buscar, insertar y borrar en un tiempo O(log n), donde n es el
nmero de elementos del rbol.
En los rboles rojo-negro las hojas no son relevantes y no contienen datos. A la hora de
implementarlo en un lenguaje de programacin, para ahorrar memoria, un nico nodo
(nodo-centinela) hace de nodo hoja para todas las ramas. As, todas las referencias de los
nodos internos a las hojas van a parar al nodo centinela.
En los rboles rojo-negros, como en todos los rboles binarios de bsqueda, es posible moverse
ordenadamente a travs de los elementos de forma eficiente si hay forma de localizar el padre de
cualquier nodo. El tiempo de desplazarse desde la raz hasta una hoja a travs de un rbol
equilibrado que tiene la mnima altura posible es de O(log n).
Propiedades:
Un rbol rojo-negro es un rbol binario de bsqueda en el que cada nodo tiene un atributo
de color cuyo valor es o bien rojo o bien negro. Adems de los requisitos impuestos a los
rboles binarios de bsqueda convencionales, se deben satisfacer los siguientes para
tener un rbol rojo-negro vlido:
1. Todo nodo es o bien rojo o bien negro.
2. La raz es negra.
3. Todas las hojas son negras (las hojas son los hijos nulos).
4. Los hijos de todo nodo rojo son negros (tambin llamada "Propiedad del rojo").

Programacin III, Gua 7

5. Cada camino simple desde un nodo a una hoja descendiente contiene el mismo
nmero de nodos negros, ya sea contando siempre los nodos negros nulos, o bien no
contndolos nunca (el resultado es equivalente). Tambin es llamada "Propiedad del
camino", y al nmero de nodos negros de cada camino, que es constante para todos los
Caminos, se le denomina "Altura negra del rbol", y por tanto el camino no puede tener
dos rojos seguidos.

6. El camino ms largo desde la raz hasta una hoja no es ms largo que 2 veces el
camino ms corto desde la raz del rbol a una hoja en dicho rbol. El resultado es que
dicho rbol est aproximadamente equilibrado

MATERIAL Y EQUIPO
N

Cantidad

Descripcin

Gua de Programacin #7
Programacin III

Dispositivo de memoria

Programacin III, Gua 7

Procedimiento
Materiales y equipo
Procedimiento
1. Cree un proyecto modo consola en Visual C# .NET y nmbrelo como
BinarySearchTree.cs
using System;
using Sytem.Collections.Generic;
using System.Text;
namespace BinaryTree
{
public class Node
{
public String data;
public Object key;
public Node left, right;
public Node(Object key, String data)
{
this.data = data;
this.key = key;
left = null;
right = null;
}
}
public class BinarySearchTree
{
private Node root;
private int count = 0;
public BinarySearchTree()
{
root = null;
count = 0;
}
public int Count
{
get
{
return this.count;
}
set
{
this.count = value;
}
}
public Node Root
{
get { return this.root; }
}
private void CreateNode(Node node, ref Node tree)
{
if (tree == null)

Programacin III, Gua 7

tree = node;
else
{
int result = String.Compare(node.key.ToString(), tree.key.ToString());
if (result == 0)
throw new Exception("Duplicate key...");
else if (result < 0)
CreateNode(node, ref tree.left);
else
CreateNode(node, ref tree.right);
}
}
public Node Insert(Object key, String data)
{
Node node = new Node(key, data);
try
{
if (root == null)
root = node;
else
CreateNode(node, ref root);
this.Count++;
return node;
}
catch
{
return null;
}
}
public Node Search(Node node, Object key)
{
if (node == null)
return null;
else
{
int result = String.Compare(key.ToString(), node.key.ToString());
if (result < 0)
return Search(node.left, key);
else if (result > 0)
return Search(node.right, key);
else
return node;
}
}
}
}

Programacin III, Gua 7

2. Ahora cree otro archivo con el nombre Program.cs
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Text;
namespace Trees
{
public enum Color
{
Red = 0, Black = 1
}
public enum Direction
{
Left, Right
}
public class Node
{
public IComparable data;
public Node left;
public Node right;
public Color color = Color.Black;
public Node(IComparable data) : this(data, null, null)
{
}
public Node(IComparable data, Node left, Node right)
{
this.data = data;
this.left = left;
this.right = right;
}
}
public class Tree
{
protected Node root;
protected Node freshNode;
protected Node currentNode;
protected Tree()
{

Programacin III, Gua 7

freshNode = new Node(null);
freshNode.left = freshNode.right = freshNode;
root = new Node(null);
root.left = freshNode;
root.right = freshNode;
}

protected int Compare(IComparable item, Node node)

{
if (node != root)
return item.CompareTo(node.data);
else
return 1;
}
public IComparable Search(IComparable data)
{
freshNode.data = data;
currentNode = root.right;
while (true)
{
if (Compare(data, currentNode) < 0)
currentNode = currentNode.left;
else if (Compare(data, currentNode) > 0)
currentNode = currentNode.right;
else if (currentNode != freshNode)
return currentNode.data;
else
return null;
}
}
protected void Display()
{
this.Display(root.right);
}
protected void Display(Node temp)
{
if (temp != freshNode)

Programacin III, Gua 7

{
Display(temp.left);
Console.WriteLine(temp.data);
Display(temp.right);
}
}
}
public sealed class RedBlackTree : Tree
{
private Color Black = Color.Black;
private Color Red = Color.Red;
private Node parentNode;
private Node grandParentNode;
private Node tempNode;
public RedBlackTree()
{
}
public void Insert(IComparable item)
{
currentNode = parentNode = grandParentNode = root;
freshNode.data = item;
int returnedValue = 0;
while (Compare(item, currentNode) != 0)
{
tempNode = grandParentNode;
grandParentNode = parentNode;
parentNode = currentNode;
returnedValue = Compare(item, currentNode);
if (returnedValue < 0)
currentNode = currentNode.left;
else
currentNode = currentNode.right;
if (currentNode.left.color == Color.Red && currentNode.right.color == Color.Red)
ReArrange(item);
}
if (currentNode == freshNode)

Programacin III, Gua 7

{
currentNode = new Node(item, freshNode, freshNode);
if (Compare(item, parentNode) < 0)
parentNode.left = currentNode;
else
parentNode.right = currentNode;
ReArrange(item);
}
}
private void ReArrange(IComparable item)
{
currentNode.color = Red;
currentNode.left.color = Color.Black;
currentNode.right.color = Color.Black;
if (parentNode.color == Color.Red)
{
grandParentNode.color = Color.Red;
bool compareWithGrandParentNode = (Compare(item, grandParentNode) < 0);
bool compareWithParentNode = (Compare(item, parentNode) < 0);
if (compareWithGrandParentNode != compareWithParentNode)
parentNode = Rotate(item, grandParentNode);
currentNode = Rotate(item, tempNode);
currentNode.color = Black;
}
root.right.color = Color.Black;
}
}
private Node Rotate(IComparable item, Node parentNode)
{
int value;
if (Compare(item, parentNode) < 0)
{
value = Compare(item, parentNode.left);
if (value < 0)
parentNode.left = this.Rotate(parentNode.left, Direction.Left);
else

Programacin III, Gua 7

parentNode.left = this.Rotate(parentNode.left, Direction.Right);

return parentNode.left;
}
else
{
value = Compare(item, parentNode.right);
if (value < 0)
parentNode.right = this.Rotate(parentNode.right, Direction.Left);
else
parentNode.right = this.Rotate(parentNode.right,
Direction.Right);
return parentNode.right;
}
}

private Node Rotate(Node node, Direction direction)

{
Node tempNode;
if (direction == Direction.Left)
{
tempNode = node.left;
node.left = tempNode.right;
tempNode.right = node;
return tempNode;
}
else
{
tempNode = node.right;
node.right = tempNode.left;
tempNode.left = node;
return tempNode;
}
}
public static void Main(String[] args)
{
RedBlackTree redBlackTree = new RedBlackTree();

Programacin III, Gua 7

1
0

BinaryTree.BinarySearchTree binarySearchTree = new BinaryTree.BinarySearchTree();

Console.WriteLine("ARBOL ROJO-NEGRO");
Console.WriteLine("ingreso de datos en arbol Rojo Negro");
for (int i = 0; i < 9000000; i++)
{
redBlackTree.Insert(i);
}
Console.WriteLine("ingreso de datos en arbol de busqueda");
for (int p = 0; p < 9000000; p++)
{
binarySearchTree.Insert(p, p.ToString());
}
DateTime startTime = DateTime.Now;
Console.WriteLine("Buscando dato 4596126 dentro del arbol rojo negro");
redBlackTree.Search(4596126);
DateTime endTime = DateTime.Now;
TimeSpan timeElasped = (TimeSpan)(endTime - startTime);
Console.WriteLine("Arbol

Rojo

Negro

tiempo

de

busqueda:

"

timeElasped.Milliseconds.ToString() + " milisegundos.");

startTime = DateTime.Now;
Console.WriteLine("Buscando dato 4596126 dentro arbol de busqueda");
binarySearchTree.Search(binarySearchTree.Root, "4596126");
endTime = DateTime.Now;
timeElasped = (TimeSpan)(endTime - startTime);
Console.WriteLine("Arbol

binario

tiempo

de

busqueda:

"

timeElasped.Milliseconds.ToString() + "milisegundos.");
Console.Read();
}
}
}

Investigacin complementaria.
. Hacer un men que permita insertar n valores (automtico o manual) y que adems me
permita realizar bsquedas mediante el rbol rojo negro o mediante el rbol de bsqueda
y que imprima el tiempo de ejecucin.

Programacin III, Gua 7

1
1
Investigue el funcionamiento de los arboles B (B- Trees). Qu diferencias y similitudes
tienen con los otros rboles desarrollados.

Bibliografa.
DEITEL, HARVEY M. / DEITEL, PAUL J. Cmo programar en C#. Editorial Pearson Prentice Hall, Mxico
2004
JOYANES AGUILAR, LUIS. Programacin en C# - Algoritmos, estructuras de datos y objetos. Editorial
McGraw Hill, Espaa 2006