public NodoArbolAVL(Object valor, NodoArbolAVL izquierdo, NodoArbolAVL derecho)
{
this.valor = valor;
this.factor_equilibrio = 0;
this.izquierdo = izquierdo;
this.derecho = derecho;
}
private NodoArbolAVL equilibrar1(NodoArbolAVL n, Logical cambiaAltura)
{
NodoArbolAVL n1;
switch (n.getFactorEquilibrio())
{
case -1:
n.setFactorEquilibrio(0);
break;
case 0:
n.setFactorEquilibrio(1);
cambiaAltura.setLogical(false);
break;
case +1: //se aplicar un tipo de rotación derecha
n1 = (NodoArbolAVL)n.getDerecho();
if (n1.getFactorEquilibrio() >= 0)
{
if (n1.getFactorEquilibrio() == 0) //la altura no vuelve a disminuir
{
cambiaAltura.setLogical(false);
}
n = rotacionDD(n, n1);
}
else
{
n = rotacionDI(n, n1);
}
break;
}
return(n);
}
private NodoArbolAVL equilibrar2(NodoArbolAVL n, Logical cambiaAltura)
{
NodoArbolAVL n1;
switch (n.getFactorEquilibrio())
{
case -1: // Se aplica un tipo de rotación izquierda
n1 = (NodoArbolAVL)n.getIzquierdo();
if (n1.getFactorEquilibrio() <= 0)
{
if (n1.getFactorEquilibrio() == 0)
{
cambiaAltura.setLogical(false);
}
n = rotacionII(n, n1);
}
else
{
n = rotacionID(n, n1);
}
break;
case 0:
n.setFactorEquilibrio(-1);
cambiaAltura.setLogical(false);
break;
case +1:
n.setFactorEquilibrio(0);
break;
}
return(n);
}
protected Object igualar(NodoArbolAVL raizSub, Object valor1, Object valor2)
{
if (raizSub == null)
{
return(null);
}
Comparador comparador;
comparador = (Comparador)raizSub.getValor();
if (comparador.igualar(valor1, valor2))
{
return(raizSub.getValor());
}
if (igualar(raizSub.getIzquierdo(), valor1, valor2) != null)
{
return(igualar(raizSub.getIzquierdo(), valor1, valor2));
}
else
{
return(igualar(raizSub.getDerecho(), valor1, valor2));
}
}
public void insertar(Object valor)//throws Exception
{
Comparador dato;
Logical h = new Logical(false); // intercambia un valor booleano
dato = (Comparador)valor;
this.raiz = insertarAvl(this.raiz, dato, h);
}
// Recorrido de un árbol binario en postorden
public static string postorden(NodoArbolAVL r)
{
if (r != null)
{
return(postorden(r.getIzquierdo()) + postorden(r.getDerecho()) + r.visitar());
}
return("");
}
public void eliminar(Object valor) //throws Exception
{
Comparador dato;
dato = (Comparador)valor;
Logical flag = new Logical(false);
raiz = borrarAvl(raiz, dato, flag);
}
private NodoArbolAVL borrarAvl(NodoArbolAVL r, Comparador clave, Logical cambiaAltura) //throws Exception
{
if (r == null)
{
throw new Exception(" Nodo no encontrado ");
}
else if (clave.menorQue(r.getValor()))
{
NodoArbolAVL iz;
iz = borrarAvl((NodoArbolAVL)r.getIzquierdo(), clave, cambiaAltura);
r.setIzquierdo(iz);
if (cambiaAltura.booleanValue())
{
r = equilibrar1(r, cambiaAltura);
}
}
else if (clave.mayorQue(r.getValor()))
{
NodoArbolAVL dr;
dr = borrarAvl((NodoArbolAVL)r.getDerecho(), clave, cambiaAltura);
r.setDerecho(dr);
if (cambiaAltura.booleanValue())
{
r = equilibrar2(r, cambiaAltura);
}
}
else // Nodo encontrado
{
NodoArbolAVL q;
q = r; // nodo a quitar del árbol
if (q.getIzquierdo() == null)
{
r = (NodoArbolAVL)q.getDerecho();
cambiaAltura.setLogical(true);
}
else if (q.getDerecho() == null)
{
r = (NodoArbolAVL)q.getIzquierdo();
cambiaAltura.setLogical(true);
}
else
{ // tiene rama izquierda y derecha
NodoArbolAVL iz;
iz = reemplazar(r, (NodoArbolAVL)r.getIzquierdo(), cambiaAltura);
r.setIzquierdo(iz);
if (cambiaAltura.booleanValue())
{
r = equilibrar1(r, cambiaAltura);
}
}
q = null;
}
return(r);
}
//Obtener el nodo mayor.
public Object getMayor(NodoArbolAVL r)
{
if (r.getDerecho() != null)
{
return(getMayor(r.getDerecho()));
}
else
{
return(r.getValor());
}
}
//Devuelve el número de nodos que tiene el árbol
public static int numNodos(NodoArbolAVL raiz)
{
if (raiz == null)
{
return(0);
}
else
{
return(1 + numNodos(raiz.getIzquierdo()) +
numNodos(raiz.getDerecho()));
}
}
private NodoArbolAVL reemplazar(NodoArbolAVL n, NodoArbolAVL act, Logical cambiaAltura)
{
if (act.getDerecho() != null)
{
NodoArbolAVL d;
d = reemplazar(n, (NodoArbolAVL)act.getDerecho(), cambiaAltura);
act.setDerecho(d);
if (cambiaAltura.booleanValue())
{
act = equilibrar2(act, cambiaAltura);
}
}
else
{
n.setValor(act.getValor());
n = act;
act = (NodoArbolAVL)act.getIzquierdo();
n = null;
cambiaAltura.setLogical(true);
}
return(act);
}
private NodoArbolAVL rotacionDD(NodoArbolAVL nodo, NodoArbolAVL nodo2)
{
nodo.setDerecho(nodo2.getIzquierdo());
nodo2.setIzquierdo(nodo);
using (StreamWriter w = File.AppendText("C:\\Users\\kyone\\Desktop" + "/Bitacora.txt"))
{
w.WriteLine("Factor de equilibrio = " + (nodo.getFactorEquilibrio() + nodo2.getFactorEquilibrio()) + "; Nodos en la rotación = " + nodo.getValor().ToString() + ", " + nodo2.getValor().ToString() + "; Rotación DD");
}
// actualización de los factores de equilibrio
if (nodo2.getFactorEquilibrio() == +1) // se cumple en la inserción
{
nodo.setFactorEquilibrio(0);
nodo2.setFactorEquilibrio(0);
}
else
{
nodo.setFactorEquilibrio(+1);
nodo2.setFactorEquilibrio(+1);
}
return(nodo2);
}
public void setDerecho(NodoArbolAVL derecho)
{
this.derecho = derecho;
}
public ArbolAVL()
{
this.raiz = null;
}
public ArbolAVL(Object valor)
{
this.raiz = new NodoArbolAVL(valor);
}
public void setIzquierdo(NodoArbolAVL izquierdo)
{
this.izquierdo = izquierdo;
}
public NodoArbolAVL(Object valor)
{
this.valor = valor;
this.factor_equilibrio = 0;
this.izquierdo = this.derecho = null;
}
private NodoArbolAVL insertarAvl(NodoArbolAVL raiz, Comparador dt, Logical h)
{
NodoArbolAVL n1;
if (raiz == null)
{
raiz = new NodoArbolAVL(dt);
h.setLogical(true);
}
else if (dt.menorQue(raiz.getValor()))
{
NodoArbolAVL iz;
iz = insertarAvl((NodoArbolAVL)raiz.getIzquierdo(), dt, h);
raiz.setIzquierdo(iz);
// regreso por los nodos del camino de búsqueda
if (h.booleanValue())
{
// decrementa el fe por aumentar la altura de rama izquierda
switch (raiz.getFactorEquilibrio())
{
case 1:
raiz.setFactorEquilibrio(0);
h.setLogical(false);
break;
case 0:
raiz.setFactorEquilibrio(-1);
break;
case -1: // aplicar rotación a la izquierda
n1 = (NodoArbolAVL)raiz.getIzquierdo();
if (n1.getFactorEquilibrio() == -1)
{
raiz = rotacionII(raiz, n1);
}
else
{
raiz = rotacionID(raiz, n1);
}
h.setLogical(false);
break;
}
}
}
else if (dt.mayorQue(raiz.getValor()))
{
NodoArbolAVL dr;
dr = insertarAvl((NodoArbolAVL)raiz.getDerecho(), dt, h);
raiz.setDerecho(dr);
// regreso por los nodos del camino de búsqueda
if (h.booleanValue())
{
// incrementa el fe por aumentar la altura de rama izquierda
switch (raiz.getFactorEquilibrio())
{
case 1: // aplicar rotación a la derecha
n1 = (NodoArbolAVL)raiz.getDerecho();
if (n1.getFactorEquilibrio() == +1)
{
raiz = rotacionDD(raiz, n1);
}
else
{
raiz = rotacionDI(raiz, n1);
}
h.setLogical(false);
break;
case 0:
raiz.setFactorEquilibrio(+1);
break;
case -1:
raiz.setFactorEquilibrio(0);
h.setLogical(false);
break;
}
}
}
else
{
throw new Exception("No puede haber claves repetidas ");
}
return(raiz);
}
