ALGORITMO PARA INSERCION:

1. Si el árbol esta vacio.

Se crea el nodo raíz y terminar el proceso.
2. Se compara la clave a insertar con la raíz del árbol. Si es mayor, debe
avanzarse hacia el subárbol derecho. Si es menor, debe avanzarse hacia el
subárbol izquierdo.
3. Repetir sucesivamente el paso 1 hasta que se cumpla alguna de las siguientes
condiciones.
Si el subárbol derecho o izquierdo es igual a vacío, se procede a insertar el
elemento en el lugar que le corresponde.
4. Si la clave que se quiere insertar esta en el nodo analiza no se llevar
a cabo la inserción.

ALGORITMO BUSQUEDA:
1. Verificar que el árbol no este vacío.
Se devuelve el valor NULO(null)
2. Se debe comparar la clave buscar con el campo información(clave) del nodo
Si es igual se vuelve el nodo encontrado.
Si es mayor, debe avanzarse hacia el subárbol derecho y continuar la búsqueda
devolviendo la ligar o rama derecha y regresa al paso 1.
3. Si es menor, debe avanzarse hacia el subárbol izquierdo y continuar la
búsqueda devolviendo la liga o rama izquierda y regresar al paso 1.

ALGORITMO ELIMINACION:
1. Buscar el elemento.
2. Se el elemento a eliminar es terminal una hoja, se suprime redifiniendo el
puntero del predecesor.
3. Si el elemento a eliminar tiene un solo descendiente, entonces tiene que
sustituirse por ese descendiente.
4. Si el elemento a eliminar tiene los dos descendientes, entonces se tiene que
sustituir por el nodo que se encuentra mas a la izquierda en el subárbol
derecho o por el nodo que se encuentra mas a la derecha en el subárbol
izquierdo.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.NetworkInformation;
using System.Reflection.Emit;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;

namespace TareaABB
{
public class ABB
{

public NodoArbol nodoRaiz;

public NodoArbol NodoAnterior, NodoSiguiente, NodoRecorrido, NodoAuxiliar;

int dato;
 public bool Grado1 = false, Grado2 = false;

public ABB()
{
nodoRaiz = null;
}

public void InsertarNodo()

{
NodoArbol NuevoNodo = new NodoArbol(dato);
Console.WriteLine("Ingrese el dato para el ABB: ");

dato = Convert.ToInt32(Console.ReadLine());

NuevoNodo.Dato = dato;

if(nodoRaiz == null)
{
nodoRaiz = NuevoNodo;

}
else if(BuscarDato(dato)!= null)
{
Console.WriteLine("El nodo ingresado: \n" + dato + ": ya se registro
en el Arbol");

}
else
{
NodoArbol NodoAnterior = null;
NodoArbol NodoRecorrido = nodoRaiz;

while(NodoRecorrido != null)
{
NodoAnterior = NodoRecorrido;
if(dato < NodoRecorrido.Dato)
{
NodoRecorrido = NodoRecorrido.RamaIzquierda;
}
else
{
NodoRecorrido = NodoRecorrido.RamaDerecha;
}
}

if(dato < NodoAnterior.Dato)

{
 NodoAnterior.RamaIzquierda = NuevoNodo;
Grado1 = true;
}
else
{
NodoAnterior.RamaDerecha = NuevoNodo;
Grado2 = true;
}
}
}

private void ImprimirPreOrden(NodoArbol NodoRecorrido)

{
if( NodoRecorrido != null)
{
Console.Write(NodoRecorrido.Dato + "\n");
ImprimirPreOrden(NodoRecorrido.RamaIzquierda);
ImprimirPreOrden(NodoRecorrido.RamaDerecha);
}
}

public void ImprimirPreOrden()

{
ImprimirPreOrden(nodoRaiz);
Console.WriteLine();
}
private void ImprimirInOrden(NodoArbol NodoRecorrido)
{
if(NodoRecorrido != null)
{
ImprimirInOrden(NodoRecorrido.RamaIzquierda);

Console.Write(NodoRecorrido.Dato + "\n");

ImprimirInOrden(NodoRecorrido.RamaDerecha);
}
}
public void ImprimirInOrden()
{
ImprimirInOrden(nodoRaiz);
Console.WriteLine();
}

private void ImprimirPostOrden(NodoArbol NodoRecorrido)

{
if(NodoRecorrido != null)
{
ImprimirPostOrden(NodoRecorrido.RamaIzquierda);
ImprimirPostOrden(NodoRecorrido.RamaDerecha);
Console.Write(NodoRecorrido.Dato + "\n");

}
}

public void ImprimirPostOnden()

{
ImprimirPostOrden(nodoRaiz);
Console.WriteLine();
 }

public void BusquedaDato()

{
if (nodoRaiz == null)
{
Console.Write("El arbol esta vacio");
}
else
{
Console.WriteLine("Ingrese el dato que busca");
dato = Convert.ToInt32(Console.ReadLine());

if( dato == nodoRaiz.Dato)

{
Console.WriteLine("\tVALOR ENCONTRADO\n");
Console.WriteLine("El valor es raiz del arbol: " +
nodoRaiz.Dato );
}

else
{

if(BuscarDato(dato)== null)
{
Console.WriteLine("El valor buscao " + dato + " no se
encuentra en el arbol");
}
else
{
Console.Write("El valor buscado" + ": " +dato +"\n");

}
}
}

public NodoArbol BuscarDato(int dato)

{
NodoArbol NodoRecorrido = nodoRaiz;

while (NodoRecorrido.Dato != dato)

{
if(dato < NodoRecorrido.Dato)
{
NodoRecorrido = NodoRecorrido.RamaIzquierda;
}
else
{
NodoRecorrido = NodoRecorrido.RamaDerecha;
}
if(NodoRecorrido == null)
{
return null;
}
 }
return NodoRecorrido;
}

public Boolean EliminarDato()

{
if(nodoRaiz == null)
{
Console.Write("Arbol vacio");
}
else if(BuscarDato(dato)== null)
{
Console.WriteLine("EL VALOR BUSCADO: " + dato + "\nNO SE ENCUENTRA
EN EL ARBOL");

}
else
{
Console.WriteLine("Ingrese el valor que dese eliminar");
dato = Convert.ToInt32(Console.ReadLine());

NodoArbol NodoRecorrido = nodoRaiz;

NodoArbol NodoPadre = nodoRaiz;
Boolean HijoIzquierdo = true;

while(NodoRecorrido.Dato != dato)
{
NodoPadre = NodoRecorrido;

if(dato < NodoRecorrido.Dato)

{
HijoIzquierdo = true;
NodoRecorrido = NodoRecorrido.RamaIzquierda;
}
else
{
HijoIzquierdo = false;
NodoRecorrido = NodoRecorrido.RamaDerecha;
}
}

if(NodoRecorrido.RamaIzquierda == null && NodoRecorrido.RamaDerecha

== null)
{
if(NodoRecorrido == nodoRaiz)
{
nodoRaiz = null;
}
else if (HijoIzquierdo)
{
NodoPadre.RamaIzquierda = null;
}
else
{
NodoPadre.RamaDerecha = null;
}
}
 else if(NodoRecorrido.RamaDerecha == null)
{
if (NodoRecorrido == nodoRaiz)
{
nodoRaiz = NodoRecorrido.RamaIzquierda;

}
else if(HijoIzquierdo)
{
NodoPadre.RamaIzquierda = NodoRecorrido.RamaIzquierda;
}
else
{
NodoPadre.RamaDerecha = NodoRecorrido.RamaIzquierda;
}
}
else if( NodoRecorrido.RamaIzquierda == null)
{

if(NodoRecorrido == nodoRaiz)
{
nodoRaiz = NodoRecorrido.RamaDerecha;
}
else if (HijoIzquierdo)
{
NodoPadre.RamaIzquierda = NodoRecorrido.RamaDerecha;
}
else
{
NodoPadre.RamaDerecha = NodoRecorrido.RamaIzquierda;
}
}
else
{
NodoArbol NodoReemplazo = ObtenerNodoReemplazo(NodoRecorrido);

if(NodoRecorrido == nodoRaiz)
{
nodoRaiz = NodoReemplazo;
}
else if (HijoIzquierdo)
{
NodoPadre.RamaIzquierda = NodoReemplazo;
}
else
{
NodoPadre.RamaDerecha = NodoReemplazo;
}

NodoReemplazo.RamaIzquierda = NodoRecorrido.RamaIzquierda;
}

}
return true;
 }
public NodoArbol ObtenerNodoReemplazo(NodoArbol NodoReem)
{
NodoArbol NodoReemplazoPadre = NodoReem;
NodoArbol NodoReemplazo = NodoReem;
NodoArbol NodoRecorrido = NodoReem.RamaDerecha;

while(NodoRecorrido != null)
{
NodoReemplazoPadre = NodoReemplazo;
NodoReemplazo = NodoRecorrido;
NodoRecorrido = NodoRecorrido.RamaIzquierda;
}
if(NodoReemplazo != NodoReem.RamaDerecha)
{
NodoReemplazoPadre.RamaIzquierda = NodoReemplazo.RamaDerecha;
NodoReemplazo.RamaDerecha = NodoReem.RamaDerecha;
}
Console.WriteLine("El nodo remplazo dl nodo eliminado es " +
NodoReemplazo.Dato );

return NodoReemplazo;
}

public void EsRaiz()

{
if(nodoRaiz == null)
{
Console.WriteLine("El arbol esta vacio");
}
else
{
Console.WriteLine("La raiz del arbol es " + nodoRaiz.Dato );
}
}

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

namespace TareaABB
{
public class NodoArbol
{

public NodoArbol RamaIzquierda { get; set; }

public int Dato { get; set; }

 public int Lef { get; set; }

public NodoArbol RamaDerecha { get; set; }

public NodoArbol(int dato)

{

RamaIzquierda = null;
this.Dato = dato;

RamaDerecha = null;

}
}

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

namespace TareaABB
{
class Program
{
static void Main(string[] args)
{

try
{
ABB ArbolBB = new ABB();

byte Opcion = 0;

do
{
Console.WriteLine("Menu principal");
Console.WriteLine("..........................");
Console.WriteLine("1. Insertar nodo en el arbol");

Console.WriteLine("2.Buscar nodo en el arbol");

Console.WriteLine("3. Eliminar nodo en el arbol");
Console.WriteLine("4. Imprimir nodo en el arbol");
Console.WriteLine("5. Salir");

Console.WriteLine("Selecione una opcion");

Opcion = Convert.ToByte(Console.ReadLine());
switch (Opcion)
{
case 1:
Console.Clear();
Console.WriteLine("Inserta nodo en el arbol");
ArbolBB.InsertarNodo();
break;

case 2:
Console.WriteLine("Inserta el nodo que buscas");
ArbolBB.BusquedaDato();
break;

case 3:

Console.Clear();
Console.WriteLine("\nELIMINAR NODO EN EL ARBOL...");
ArbolBB.EliminarDato();
Console.Clear();
Console.WriteLine("Borraste un nodo del arbol...");
Console.ReadKey();
break;

case 4:

Console.Clear();
Console.WriteLine("Raiz.");
ArbolBB.EsRaiz();
Console.WriteLine("Imprir albol inOrde.");
ArbolBB.ImprimirInOrden();

Console.WriteLine("Imprimir arbol PostOrden.");

ArbolBB.ImprimirPostOnden();

Console.WriteLine("Imprimir arbol Preorden.");

ArbolBB.ImprimirPreOrden();

Console.ReadKey();
break;

case 5:
Console.Clear();

Console.WriteLine("* PROGRAMA TERMINADO *");

Console.ReadKey();
break;

default:
Console.Clear();

Console.WriteLine("** OPC INCORRECTA **");

Console.ReadKey();
break;
 }

}
while (Opcion != 5);
}
catch (FormatException e)
{
Console.WriteLine("******************************");
Console.WriteLine("ERROR" + e.Message);
Console.WriteLine("******************************");
}

}
}
}