You are on page 1of 16

INSTITUTO TECNOLOGICO SUPERIOR DEL OCCIDENTE DEL ESTADO DE HIDALGO

ING. EN SISTEMAS COMPUTACIONALES



ESTRUCTURA DE DATOS

3-A


ARBOL BINARIO DE BUSQUEDA


ALUMNO: RICARDO JIMENEZ MICETE Y LUIS FELIPE PEREZ CRUZ


MAESTRO: GUILLERMO CASTAEDA ORTIZ

Diagrama de la clase Nodo


Clase NodoABB

-private NodoABB hijoizq
-private int dato
-private NodoABB hijoder

+public NodoABB()
+public set dato()
+public get dato()
+public set hijoizq()
+public get hijoizq()
+public set hijoder()
+public get hijoder()


Cdigo de la clase Nodo
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Arboles2
{
class NodoArbolBinarioBusqueda
{
private NodoArbolBinarioBusqueda hijoizq;
private int dato;
private NodoArbolBinarioBusqueda hijoder;

// Constructor
public NodoArbolBinarioBusqueda()
{
HijoDer = null;
HijoIzq = null;
Nodo

izq
int

dato
Nodo

der
}

// Propiedad pblica para acceder al dato
public int Dato
{
get { return (dato); }
set { dato = value; }
}

// Propiedad pblica para acceder al hijo izquierdo
public NodoArbolBinarioBusqueda HijoIzq
{
get { return (hijoizq); }
set { hijoizq = value; }
}

// Propiedad pblica para acceder al hijo derecho
public NodoArbolBinarioBusqueda HijoDer
{
get { return (hijoder); }
set { hijoder = value; }
}
}
}












Diagrama de la Clase ArbolABB
raiz













Cdigo de la Clase ArbolABB
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Arboles2
{
class ArbolBinarioBusqueda
{
// Declaracin privada de la raz del ABB
private NodoArbolBinarioBusqueda raiz;

// Constructor
public ArbolBinarioBusqueda()
{
Raiz = null; // Inicializa el ABB vaco
}
Clase ArbolBianrioDeBusqueda
- private NodoABB raiz;

+public ArbolBianrioDeBusqueda()
+public setRaiz
+public getRaiz
+public bool Insertar(NodoABB)
+public void PreOrden(NodoABB, ref string)
+public bool Buscar(NodoABB)
+public void PreOrden(NodoABB, string)
+public void InOrden(NodoABB, ref string)
+public void PostOrden(NodoABB, ref string )
+public void Vaciar()
-private void RecorrerYBorrar(NodoABB)
d
b
f
g
a c e

// Propiedad pblica para acceder a la raz
public NodoArbolBinarioBusqueda Raiz
{
get { return (raiz); }
set { raiz = value; }
}

// Mtodo pblico para detectar si el ABB est vaco
public bool EstaVacio()
{
if (Raiz == null)
return (true);
else
return (false);
}

// Mtodo pblico que recibe como argumento el Nodo que se desea insertar
public bool Insertar(NodoArbolBinarioBusqueda Nodo)
{
NodoArbolBinarioBusqueda NuevoNodo;

if (EstaVacio()) // Si el ABB est vaco
{
// Creacin del NuevoNodo
NuevoNodo = new NodoArbolBinarioBusqueda();
NuevoNodo = Nodo;
Raiz = NuevoNodo; // Establecer la Raz
return (true); // Insercin exitosa
}
else
{
NodoArbolBinarioBusqueda NodoActual = Raiz;
NodoArbolBinarioBusqueda Padre = null;

// Inicia el recorrido del ABB hasta llegar a una hoja
while (NodoActual != null)
{
// Verifica si est duplicado
if (NodoActual.Dato == Nodo.Dato)
return (false); // No se insert ... duplicado

// Verifica el subrbol que debe recorrer
if (Nodo.Dato < NodoActual.Dato)
{
Padre = NodoActual; // Recorre el subrbol izquierdo
NodoActual = NodoActual.HijoIzq;
}
else
{
Padre = NodoActual; // Recorre el subrbol derecho
NodoActual = NodoActual.HijoDer;
}
}

// Creacin del nuevo nodo
NuevoNodo = new NodoArbolBinarioBusqueda();
NuevoNodo = Nodo;

if (Nodo.Dato < Padre.Dato)
Padre.HijoIzq = NuevoNodo; // Se inserta por la Izquierda
else
Padre.HijoDer = NuevoNodo; // Se inserta por la Derecha

return (true); // Insercin exitosa
}
}

// Mtodo pblico que recibe como argumento el Nodo que se desea eliminar
public bool Eliminar(NodoArbolBinarioBusqueda Nodo)
{
if (EstaVacio()) // Verifica si el ABB est vaco
return (false); // No se elimin... est vaco

NodoArbolBinarioBusqueda NodoActual = Raiz, Padre = null;

// Bsqueda del nodo que se desea eliminar
while (NodoActual.Dato != Nodo.Dato)
{
if (Nodo.Dato < NodoActual.Dato)
{
Padre = NodoActual;
NodoActual = NodoActual.HijoIzq; // Recorre el subrbol izquierdo
}
else
{
if (Nodo.Dato > NodoActual.Dato)
{
Padre = NodoActual;
NodoActual = NodoActual.HijoDer; // Recorre el subrbol derecho
}
}

if (NodoActual == null)
return (false); // No se elimin ... no existe el nodo
}

// Se encontr el nodo que se desea eliminar

// Caso 1: Si el NodoActual no tiene hijo derecho entonces su hijo izquierdo se convierte en
// el nodo apuntado por su Padre
if (NodoActual.HijoDer == null)
{
if (Padre == null)
Raiz = NodoActual.HijoIzq;
else
{
if (Padre.Dato > NodoActual.Dato)
Padre.HijoIzq = NodoActual.HijoIzq;
else
{
if (Padre.Dato < NodoActual.Dato)
Padre.HijoDer = NodoActual.HijoIzq;
}
}
}
else
{
// Caso 2: Si el hijo derecho del NodoActual no tiene hijo izquierdo entonces el hijo derecho
// del NodoActual reemplaza al NodoActual

if (NodoActual.HijoDer.HijoIzq == null)
{
NodoActual.HijoDer.HijoIzq = NodoActual.HijoIzq;
if (Padre == null)
Raiz = NodoActual.HijoDer;
else
{
if (Padre.Dato > NodoActual.Dato)
Padre.HijoIzq = NodoActual.HijoDer;
else
{
if (Padre.Dato < NodoActual.Dato)
Padre.HijoDer = NodoActual.HijoDer;
}
}
}
else
{
// Caso 3: Si el hijo derecho del NodoActual tiene hijo izquierdo se reemplaza el
// NodoActual con el hijo menor del subrbol derecho

// Inicia la bsqueda del nodo ubicado ms a la izquierda de la rama derecha

NodoArbolBinarioBusqueda NodoMenor = NodoActual.HijoDer.HijoIzq, PadreDelNodoMenor = NodoActual.HijoDer;

while (NodoMenor.HijoIzq != null)
{
PadreDelNodoMenor = NodoMenor;
NodoMenor = NodoMenor.HijoIzq;
}

// El subrbol izquierdo de su padre se convierte en el subrbol derecho del NodoMenor
PadreDelNodoMenor.HijoIzq = NodoMenor.HijoDer;

// Asigna los hijos del NodoMenor a los hijos del NodoActual
NodoMenor.HijoIzq = NodoActual.HijoIzq;
NodoMenor.HijoDer = NodoActual.HijoDer;

if (Padre == null)
Raiz = NodoMenor;
else
{
if (Padre.Dato > NodoActual.Dato)
Padre.HijoIzq = NodoMenor;
else
{
if (Padre.Dato < NodoActual.Dato)
Padre.HijoDer = NodoMenor;
}
}
}
}
return (true);
}

// Mtodo pblico que recibe como argumento el Nodo que se desea buscar
public bool Buscar(NodoArbolBinarioBusqueda Nodo)
{
if (EstaVacio())
return (false); // No se encontr... el ABB est vaco

// Inicia la bsqueda del Nodo en la Raz
NodoArbolBinarioBusqueda NodoActual = Raiz;

while (NodoActual != null)
{
if (NodoActual.Dato == Nodo.Dato)
return (true); // Bsqueda exitosa
else
if (Nodo.Dato > NodoActual.Dato)
NodoActual = NodoActual.HijoDer; // Recorre el subrbol derecho
else
NodoActual = NodoActual.HijoIzq; // Recorre el subrbol izquierdo
}
return (false); // No se encontr el nodo
}

// Mtodo pblico recursivo para recorrer el ABB en modo PreOrden
public void PreOrden(NodoArbolBinarioBusqueda NodoActual, ref string Resultado)
{
if (NodoActual != null)
{
Resultado = Resultado + "-> " + NodoActual.Dato.ToString(); // Visita el NodoActual
PreOrden(NodoActual.HijoIzq, ref Resultado); // Llamada recursiva para recorrer PreOrden el subrbol izquierdo
PreOrden(NodoActual.HijoDer, ref Resultado);// Llamada recursiva para recorrer PreOrden el subrbol derecho
}
}

// Mtodo pblico recursivo para recorrer el ABB en modo InOrden
public void InOrden(NodoArbolBinarioBusqueda NodoActual, ref string Resultado)
{
if (NodoActual != null)
{
InOrden(NodoActual.HijoIzq, ref Resultado); // Llamada recursiva para recorrer InOrden el subrbol izquierdo
Resultado = Resultado + "-> " + NodoActual.Dato.ToString(); // Visita el NodoActual
InOrden(NodoActual.HijoDer, ref Resultado); // Llamada recursiva para recorrer InOrden el subrbol derecho
}
}

// Mtodo pblico recursivo para recorrer el ABB en modo PostOrden
public void PostOrden(NodoArbolBinarioBusqueda NodoActual, ref string Resultado)
{
if (NodoActual != null)
{
PostOrden(NodoActual.HijoIzq, ref Resultado); // Llamada recursiva para recorrer PostOrden el subrbol izquierdo
PostOrden(NodoActual.HijoDer, ref Resultado); // Llamada recursiva para recorrer PostOrden el subrbol derecho
Resultado = Resultado + "-> " + NodoActual.Dato.ToString(); // Visita el NodoActual
}
}


// Mtodo pblico recursivo para vaciar el rbol Binario de Bsqueda
public void Vaciar()
{
if (!EstaVacio()) // Si no est vaco ...
{
// Se invoca el mtodo recursivo para recorrer el ABB y eliminar cada uno de sus nodos
// (iniciando en la Raiz)
RecorrerYBorrar(Raiz);

Raiz = null; // Se inicializa el ABB vaco
}
}

// Mtodo recursivo privado para recorrer el ABB y eliminar cada nodo
private void RecorrerYBorrar(NodoArbolBinarioBusqueda NodoActual)
{
if (NodoActual != null)
{
RecorrerYBorrar(NodoActual.HijoIzq); // Llamada recursiva para recorrer PostOrden el subrbol izquierdo
RecorrerYBorrar(NodoActual.HijoDer); // Llamada recursiva para recorrer PostOrden el subrbol derecho
Eliminar(NodoActual); // Elimina el NodoActual
}
}
}
}


Cdigo de la clase PruebaArbolABB

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Arboles2
{
class PruebaArbolBinarioBusqueda
{
static ArbolBinarioBusqueda ArbolBinarioBusqueda = new ArbolBinarioBusqueda();

static void Main(string[] args)
{
int opcion = 0;

NodoArbolBinarioBusqueda Nodo;

Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 90; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 50; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 150; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 20; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 75; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 95; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 175; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 5; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 25; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 66; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 80; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 92; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 111; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 166; ArbolBinarioBusqueda.Insertar(Nodo);
Nodo = new NodoArbolBinarioBusqueda(); Nodo.Dato = 200; ArbolBinarioBusqueda.Insertar(Nodo);


do
{
Console.Clear();
Console.WriteLine("\t*ARBOLES BINARIOS DE BSQUEDA*\n");
Console.WriteLine("1.- Insertar nodo");
Console.WriteLine("2.- Eliminar nodo");
Console.WriteLine("3.- Buscar nodo");
Console.WriteLine("4.- Recorrido Pre-Orden");
Console.WriteLine("5.- Recorrido In-Orden");
Console.WriteLine("6.- Recorrido Post-Orden");
Console.WriteLine("7.- Vaciar");
Console.WriteLine("0.- Salir");

Console.Write("\nOpcin? ");
opcion = int.Parse(Console.ReadLine());

switch (opcion)
{
case 1: InsertarNodo(); break;
case 2: EliminarNodo(); break;
case 3: BuscarNodo(); break;
case 4: RecorrerPreOrden(); break;
case 5: RecorrerInOrden(); break;
case 6: RecorrerPostOrden(); break;
case 7: VaciarArbol(); break;
}
} while (opcion != 0);
}

// Mtodo para capturar un dato e insertarlo en el rbol binario de bsqueda
static void InsertarNodo()
{
// Declaracin del objeto local
NodoArbolBinarioBusqueda Nodo = new NodoArbolBinarioBusqueda();

Console.Clear();
Console.WriteLine("INSERTAR DATO EN EL RBOL BINARIO DE BSQUEDA");
Console.Write("\nNmero ? ");
Nodo.Dato = int.Parse(Console.ReadLine()); // Captura del dato del nodo que se desea insertar

if (ArbolBinarioBusqueda.Insertar(Nodo)) //Se invoca el mtodo para insertar el nodo en el rbol binario de bsqueda
Console.WriteLine("\nDato insertado en el rbol Binario de Bsqueda");
else
Console.WriteLine("\nNo se insert el dato (duplicado)");
Console.ReadKey();
}

// Mtodo para capturar un dato, buscarlo y eliminarlo del rbol binario de bsqueda
static void EliminarNodo()
{
// Declaracin del objeto local
NodoArbolBinarioBusqueda Nodo = new NodoArbolBinarioBusqueda();

Console.Clear();
Console.WriteLine("ELIMINAR DATO DEL RBOL BINARIO");
Console.Write("\nNmero ? ");
Nodo.Dato = int.Parse(Console.ReadLine()); // Captura del dato del nodo que se desea eliminar

if (ArbolBinarioBusqueda.Eliminar(Nodo)) //Se invoca el mtodo para insertar el nodo en el ABB
Console.WriteLine("\nDato eliminado del rbol Binario de Bsqueda");
else
Console.WriteLine("\nNo se elimin el dato (no existe)");

Console.ReadKey();
}

// Mtodo para buscar un dato en el rbol binario de bsqueda
static void BuscarNodo()
{
// Declaracin del objeto local
NodoArbolBinarioBusqueda Nodo = new NodoArbolBinarioBusqueda();

Console.Clear();
Console.WriteLine("BUSCAR DATO EN EL RBOL BINARIO");
Console.Write("\nNmero ? ");
Nodo.Dato = int.Parse(Console.ReadLine()); // Captura del dato del nodo que se desea buscar

if (ArbolBinarioBusqueda.Buscar(Nodo)) // Se invoca el mtodo para buscar el nodo en el ABB
Console.WriteLine("\nEl Dato s est almacenado en el rbol Binario de Bsqueda");
else
Console.WriteLine("\nNo se encontr el dato (no existe)");

Console.ReadKey();
}

static void RecorrerPreOrden()
{
string Resultado = " "; // Cadena que almacena los nodos visitados

Console.Clear();
Console.WriteLine("RECORRIDO PRE-ORDEN DEL RBOL BINARIO DE BSQUEDA\n");

if (!ArbolBinarioBusqueda.EstaVacio())
{
// Se ejecuta el mtodo para recorrer los nodos almacenados en el rbol binario de bsqueda
ArbolBinarioBusqueda.PreOrden(ArbolBinarioBusqueda.Raiz, ref Resultado);
}
else
Resultado = "rbol Binario de Bsqueda vaco ...";

Console.WriteLine(Resultado+"\n"); // Despliega el Resultado

Console.ReadKey();
}

static void RecorrerInOrden()
{
string Resultado = ""; // Cadena que almacena los nodos visitados

Console.Clear();
Console.WriteLine("RECORRIDO IN-ORDEN DEL RBOL BINARIO DE BSQUEDA\n");

if (!ArbolBinarioBusqueda.EstaVacio())
{
// Se ejecuta el mtodo para recorrer los nodos almacenados en el rbol binario de bsqueda
ArbolBinarioBusqueda.InOrden(ArbolBinarioBusqueda.Raiz, ref Resultado);
}
else
Resultado = "rbol Binario de Bsqueda vaco ...";


Console.WriteLine(Resultado); // Despliega la cadena con los nodos visitados

Console.ReadKey();
}

static void RecorrerPostOrden()
{
string Resultado = ""; // Cadena que almacena los nodos visitados

Console.Clear();
Console.WriteLine("RECORRIDO POST-ORDEN DEL RBOL BINARIO DE BSQUEDA\n");

if (!ArbolBinarioBusqueda.EstaVacio())
{
// Se ejecuta el mtodo para recorrer los nodos almacenados en el rbol binario de bsqueda
ArbolBinarioBusqueda.PostOrden(ArbolBinarioBusqueda.Raiz, ref Resultado);
}
else
Resultado = "rbol Binario de Bsqueda vaco ...";


Console.WriteLine(Resultado); // Despliega la cadena con los nodos visitados

Console.ReadKey();
}

static void VaciarArbol()
{
Console.Clear();
Console.WriteLine("VACIAR EL RBOL BINARIO DE BSQUEDA\n");

// Se ejecuta el mtodo para recorrer el ABB y eliminar cada uno de sus nodos e
// inicializarlo vaco
ArbolBinarioBusqueda.Vaciar();

Console.WriteLine("Se eliminaron todos los nodos del ABB (rbol vaciado)");

Console.ReadKey();
}
}
}


Ejecucin
Menu

Prefijo


Infijo





Postfijo

You might also like