public NodoArbolAVL(T value)
{
this.value = value;
this.FactorEquilibrio = 0;
this.HijoIzquierdo = null;
this.HijoDerecho = null;
}
/// <summary>
/// Contructor de Nodo
/// </summary>
/// <param name="nodeValue">Valor del Nodo</param>
public NodoArbolAVL(T nodeValue)
{
value = nodeValue;
factorEquilibrio = 0;
hijoIzquierdo = null;
hijoDerecho = null;
}
//Rotación Doble Derecha
private NodoArbolAVL <T> RotacionDobleDerecha(NodoArbolAVL <T> Nodo)
{
NodoArbolAVL <T> Auxiliar;
Nodo.hijoDerecho = RotacionIzquierda(Nodo.hijoDerecho);
Auxiliar = RotacionDerecha(Nodo);
return(Auxiliar);
}
//Rotación Doble Izquierda
public NodoArbolAVL <T> RotacionDobleIzquierda(NodoArbolAVL <T> Nodo)
{
NodoArbolAVL <T> Auxiliar;
Nodo.HijoIzquierdo = RotacionDerecha(Nodo.HijoIzquierdo);
Auxiliar = RotacionIzquierda(Nodo);
return(Auxiliar);
}
/// <summary>
/// Metodo Recursivo que recorre el arbol
/// </summary>
/// <param name="Aux">Nodo Raiz</param>
/// <param name="Elements">Lista de Datos en Orden</param>
private void PostOrder(NodoArbolAVL <T> Aux, ref List <T> Elements)
{
if (Aux != null)
{
PostOrder(Aux.hijoIzquierdo, ref Elements);
PostOrder(Aux.hijoDerecho, ref Elements);
Elements.Add(Aux.value);
}
}
//Obtener Factor de Equilibrio
private int ObtenerFactorEquilibrio(NodoArbolAVL <T> x)
{
if (x == null)
{
return(-1);
}
else
{
return(x.factorEquilibrio);
}
}
//Rotación Simple Derecha
private NodoArbolAVL <T> RotacionDerecha(NodoArbolAVL <T> Nodo)
{
NodoArbolAVL <T> Auxiliar = Nodo.hijoDerecho;
Nodo.hijoDerecho = Auxiliar.hijoIzquierdo;
Auxiliar.hijoIzquierdo = Nodo;
//Obtiene el mayor factor de equilibrio de sus hijos.
Nodo.factorEquilibrio = Math.Max(ObtenerFactorEquilibrio(Nodo.hijoIzquierdo), ObtenerFactorEquilibrio(Nodo.hijoDerecho)) + 1;
Auxiliar.factorEquilibrio = Math.Max(ObtenerFactorEquilibrio(Auxiliar.hijoIzquierdo), ObtenerFactorEquilibrio(Auxiliar.hijoDerecho)) + 1;
return(Auxiliar);
}
public void Insertar(T value)
{
NodoArbolAVL <T> Nuevo = new NodoArbolAVL <T>(value);
if (Raiz == null)
{
Raiz = Nuevo;
}
else
{
Raiz = InsertarAVL(Nuevo, Raiz);
}
}
/// <summary>
/// Elimina un Nodo mediante sustitucion
/// </summary>
/// <param name="NodoAEliminar">Nodo a Eliminar </param>
/// <returns>Nodo de Reemplazo</returns>
private NodoArbolAVL <T> Reemplazar(NodoArbolAVL <T> NodoAEliminar)
{
NodoArbolAVL <T> remplazoPadre = NodoAEliminar;
NodoArbolAVL <T> reemplazo = NodoAEliminar;
NodoArbolAVL <T> auxiliar = NodoAEliminar.hijoDerecho;
while (auxiliar != null)
{
remplazoPadre = reemplazo;
reemplazo = auxiliar;
auxiliar = auxiliar.hijoIzquierdo;
}
if (reemplazo != NodoAEliminar.hijoDerecho)
{
remplazoPadre.hijoIzquierdo = reemplazo.hijoDerecho;
reemplazo.hijoDerecho = NodoAEliminar.hijoDerecho;
}
return(reemplazo);
}
//Buscar
/// <summary>
/// Función que recibe un valor, y devuelve un nodo que contenga ese valor
/// </summary>
/// <param name="value"> valor a buscar </param>
/// <param name="raiz"></param>
/// <returns></returns>
public NodoArbolAVL <T> Buscar(T value, NodoArbolAVL <T> raiz)
{
if (Raiz == null)
{
return(null);
}
else if (raiz.value.CompareTo(value) == 0)
{
return(raiz);
}
else if (raiz.value.CompareTo(value) == -1)
{
return(Buscar(value, raiz.HijoDerecho));
}
else
{
return(Buscar(value, raiz.HijoIzquierdo));
}
}
/// <summary>
/// Constructor de Arbol
/// </summary>
public ArbolAVL()
{
Raiz = null;
comparador = null;
}
public NodoArbolAVL <T> Eliminar(T valorEliminar, ref NodoArbolAVL <T> Raiz)
{
if (Raiz != null)
{
if (Raiz.value.CompareTo(valorEliminar) == -1)
{
nodoE = Raiz;
Eliminar(valorEliminar, ref Raiz.hijoIzquierdo);
}
else
{
if (Raiz.value.CompareTo(valorEliminar) == 1)
{
nodoE = Raiz;
Eliminar(valorEliminar, ref Raiz.hijoIzquierdo);
}
else
{
//Posicionado sobre el elemento a eliminar
NodoArbolAVL <T> NodoEliminar = Raiz;
if (NodoEliminar.hijoDerecho == null)
{
Raiz = NodoEliminar.hijoIzquierdo;
if (ObtenerFactorEquilibrio(nodoE.hijoIzquierdo) - ObtenerFactorEquilibrio(nodoE.hijoDerecho) == 2)
{
//MessageBox.Show("nodoE" + nodoE.valor.ToString());
if (nodoE.value.CompareTo(valorEliminar) == 1)
{
nodoP = RotacionIzquierda(nodoE);
}
else
{
nodoE = RotacionDerecha(nodoE);
}
}
if (ObtenerFactorEquilibrio(nodoE.hijoDerecho) - ObtenerFactorEquilibrio(nodoE.hijoIzquierdo) == 2)
{
if (nodoE.hijoDerecho.value.CompareTo(valorEliminar) == -1)
{
nodoE = RotacionDerecha(nodoE);
}
else
{
nodoE = RotacionDobleDerecha(nodoE);
}
nodoP = RotacionDerecha(nodoE);
}
}
else
{
if (NodoEliminar.hijoIzquierdo == null)
{
Raiz = NodoEliminar.hijoDerecho;
}
else
{
if (ObtenerFactorEquilibrio(Raiz.hijoIzquierdo) - ObtenerFactorEquilibrio(Raiz.hijoDerecho) > 0)
{
NodoArbolAVL <T> AuxiliarNodo = null;
NodoArbolAVL <T> Auxiliar = Raiz.hijoIzquierdo;
bool Bandera = false;
while (Auxiliar.hijoDerecho != null)
{
AuxiliarNodo = Auxiliar;
Auxiliar = Auxiliar.hijoDerecho;
Bandera = true;
}
Raiz.value = Auxiliar.value;
NodoEliminar = Auxiliar;
if (Bandera == true)
{
AuxiliarNodo.hijoDerecho = Auxiliar.hijoIzquierdo;
}
else
{
Raiz.hijoIzquierdo = Auxiliar.hijoIzquierdo;
}
//Realiza las rotaciones simples o dobles segun el caso
}
else
{
if (ObtenerFactorEquilibrio(Raiz.hijoDerecho) - ObtenerFactorEquilibrio(Raiz.hijoIzquierdo) > 0)
{
NodoArbolAVL <T> AuxiliarNodo = null;
NodoArbolAVL <T> Auxiliar = Raiz.hijoDerecho;
bool Bandera = false;
while (Auxiliar.hijoIzquierdo != null)
{
AuxiliarNodo = Auxiliar;
Auxiliar = Auxiliar.hijoIzquierdo;
Bandera = true;
}
Raiz.value = Auxiliar.value;
NodoEliminar = Auxiliar;
if (Bandera == true)
{
AuxiliarNodo.hijoIzquierdo = Auxiliar.hijoIzquierdo;
}
else
{
Raiz.hijoDerecho = Auxiliar.hijoDerecho;
}
}
else
{
if (ObtenerFactorEquilibrio(Raiz.hijoDerecho) - ObtenerFactorEquilibrio(Raiz.hijoIzquierdo) == 0)
{
NodoArbolAVL <T> AuxiliarNodo = null;
NodoArbolAVL <T> Auxiliar = Raiz.hijoIzquierdo;
bool Bandera = false;
while (Auxiliar.hijoDerecho != null)
{
AuxiliarNodo = Auxiliar;
Auxiliar = Auxiliar.hijoDerecho;
Bandera = true;
}
Raiz.value = Auxiliar.value;
NodoEliminar = Auxiliar;
if (Bandera == true)
{
AuxiliarNodo.hijoDerecho = Auxiliar.hijoDerecho;
}
else
{
Raiz.hijoIzquierdo = Auxiliar.hijoIzquierdo;
}
}
}
}
}
}
}
}
}
else
{
throw new System.InvalidOperationException("Nodo inexistente en el arbol");
}
return(nodoP);
}
//Metodo InsertarAVL
private NodoArbolAVL <T> InsertarAVL(NodoArbolAVL <T> Nuevo, NodoArbolAVL <T> SubArbol)
{
NodoArbolAVL <T> NuevoPadre = SubArbol;
if (Nuevo.value.CompareTo(SubArbol.value) == -1)
{
if (SubArbol.hijoIzquierdo == null)
{
SubArbol.hijoIzquierdo = Nuevo;
}
else
{
SubArbol.hijoIzquierdo = InsertarAVL(Nuevo, SubArbol.hijoIzquierdo);
if (ObtenerFactorEquilibrio(SubArbol.hijoIzquierdo) - ObtenerFactorEquilibrio(SubArbol.hijoDerecho) == 2)
{
if (Nuevo.value.CompareTo(SubArbol.hijoIzquierdo.value) == -1)
{
NuevoPadre = RotacionIzquierda(SubArbol);
}
else
{
NuevoPadre = RotacionDobleIzquierda(SubArbol);
}
}
}
}
else if (Nuevo.value.CompareTo(SubArbol.value) == 1)
{
if (SubArbol.hijoDerecho == null)
{
SubArbol.hijoDerecho = Nuevo;
}
else
{
SubArbol.hijoDerecho = InsertarAVL(Nuevo, SubArbol.hijoDerecho);
if (ObtenerFactorEquilibrio(SubArbol.hijoDerecho) - ObtenerFactorEquilibrio(SubArbol.hijoIzquierdo) == 2)
{
if (Nuevo.value.CompareTo(SubArbol.hijoDerecho.value) == 1)
{
NuevoPadre = RotacionDerecha(SubArbol);
}
else
{
NuevoPadre = RotacionDobleDerecha(SubArbol);
}
}
}
}
else
{
throw new System.InvalidOperationException("Nodo Duplicado");
}
//Actualizando Factor Equilibrio
if (SubArbol.hijoIzquierdo == null && SubArbol.hijoDerecho != null)
{
SubArbol.factorEquilibrio = SubArbol.hijoDerecho.factorEquilibrio + 1;
}
else if (SubArbol.hijoDerecho == null && SubArbol.hijoIzquierdo != null)
{
SubArbol.factorEquilibrio = SubArbol.hijoIzquierdo.factorEquilibrio + 1;
}
else
{
SubArbol.factorEquilibrio = Math.Max(ObtenerFactorEquilibrio(SubArbol.hijoIzquierdo), ObtenerFactorEquilibrio(SubArbol.hijoDerecho)) + 1;
}
return(NuevoPadre);
}
public ArbolAVL()
{
this.Raiz = null;
}
