private NodoAvl rotacionDI(NodoAvl n, NodoAvl n1)
{
NodoAvl n2;
n2 = (NodoAvl)n1.subarbolIzq();
n.ramaDch(n2.subarbolIzq());
n2.ramaIzq(n);
n1.ramaIzq(n2.subarbolDch());
n2.ramaDch(n1);
// factores de equilibrio en actualizacion
if (n2.fe == +1)
{
n.fe = -1;
}
else
{
n.fe = 0;
}
if (n2.fe == -1)
{
n1.fe = 1;
}
else
{
n1.fe = 0;
}
n2.fe = 0;
return(n2);
}
private NodoAvl rotacionID(NodoAvl n, NodoAvl n1)
{
NodoAvl n2;
n2 = (NodoAvl)n1.subarbolDch();
n.ramaIzq(n2.subarbolDch());
n2.ramaDch(n);
n1.ramaDch(n2.subarbolIzq());
n2.ramaIzq(n1);
// Se actualizan para la equilibracion
if (n2.fe == +1)
{
n1.fe = -1;
}
else
{
n1.fe = 0;
}
if (n2.fe == -1)
{
n.fe = 1;
}
else
{
n.fe = 0;
}
n2.fe = 0;
return(n2);
}
private static NodoAvl GetItemInterno(NodoAvl arbol, T valor)
{
if (arbol != null)
{
int t = arbol.Valor.CompareTo(valor);
if (t == 0)
{
return(arbol);
}
else if (t > 0 && arbol.HijoDercho != null)
{
return(GetItemInterno(arbol.HijoDercho, valor));
}
else if (t < 0 && arbol.HijoIzq != null)
{
return(GetItemInterno(arbol.HijoIzq, valor));
}
else
{
return(null);
}
}
else
{
return(null);
}
}
public void insertar(Object valor)
{
Comparador dato;
Logical h = new Logical(false); // Aca utlizamos la clase logical y for defecto falso
dato = (Comparador)valor; //El comprador que nos ayudara a comprar datos del arbol
arbolRaiz = insertarAvl(arbolRaiz, dato, h); //metodo recursivo para la insercion de los datos
}
private void SubeEnInsercion(NodoAvl hijo)
{
NodoAvl t = hijo;
if (t.Padre != null)
{
t.Padre.ReCalcula();
if (t.Padre.Balance == 0 || t.Padre.balPrev == t.Padre.Balance)
{
return;
}
t = t.Padre;
while (t.Padre != null)
{
t.Padre.ReCalcula();
if ((t.Padre.Balance == 0) || (t.Padre.Balance == t.Padre.balPrev))//si no afecto el balance
{
return;
}
else if (((t.Padre.Balance <= -2) || (t.Padre.Balance >= 2)) && ((t.Padre.balPrev >= 1) || (t.Padre.balPrev <= -1)))
{
//situacion de desbalance
if (t.Padre.Balance <= -2 && t.Balance <= -1)
{
t = RotaIII(t.Padre);
}
else if (t.Padre.Balance <= -2 && t.Balance >= 1)
{
t = RotaIID(t.Padre);
}
else if (t.Padre.Balance >= 2 && t.Balance >= 1)
{
t = RotaDDD(t.Padre);
}
else if (t.Padre.Balance >= 2 && t.Balance <= -1)
{
t = RotaDDI(t.Padre);
}
if (t.Padre == null)
{
raiz = t;
}
return;
}
t = t.Padre;
}
}
}
private static NodoAvl RotaDDI(NodoAvl r)
{
/* r
* \
* x
* /
* w
*/
NodoAvl x = r.HijoDercho;
NodoAvl w = x.HijoIzq;
x.HijoIzq = w.HijoDercho;
if (x.HijoIzq != null)
{
x.HijoIzq.Padre = x;
}
r.HijoDercho = w.HijoIzq;
if (r.HijoDercho != null)
{
r.HijoDercho.Padre = r;
}
w.HijoIzq = r;
w.HijoDercho = x;
w.Padre = r.Padre;
x.Padre = w;
r.Padre = w;
if (w.Padre != null)
{
if (w.Valor.CompareTo(w.Padre.Valor) > 0)
{
w.Padre.HijoIzq = w;
}
else
{
w.Padre.HijoDercho = w;
}
}
x.ReCalcula();
r.ReCalcula();
w.ReCalcula();
if (w.Padre != null)
{
w.Padre.ReCalcula();
}
return(w);
}
private void RecorreInOrderByLeft(ref int index, ref T[] array, NodoAvl arbol)
{
if (arbol.HijoIzq != null)
{
RecorreInOrderByLeft(ref index, ref array, arbol.HijoIzq);
}
array[index] = arbol.Valor;
index++;
if (arbol.HijoDercho != null)
{
RecorreInOrderByLeft(ref index, ref array, arbol.HijoDercho);
}
}
private NodoAvl rotacionDD(NodoAvl n, NodoAvl n1)
{
n.ramaDch(n1.subarbolIzq());
n1.ramaIzq(n);
// Verifica que que el arbol este en equilibrio
if (n1.fe == +1) // de ser asi se cumplira esta funcion
{
n.fe = 0;
n1.fe = 0;
}
else
{
n.fe = +1;//De lo contrario hara una rotacion derecha,derecha
n1.fe = -1;
}
return(n1);
}
private static NodoAvl GetMenorInterno(NodoAvl arbol)
{
if (arbol != null)
{
if (arbol.HijoDercho != null)
{
return(GetMenorInterno(arbol.HijoDercho));
}
else
{
return(arbol);
}
}
else
{
return(null);
}
}
public bool Insert(T item)
{
NodoAvl t = AddInterno(raiz, item);
if (t != null && raiz == null)
{
raiz = t;
}
else if (t == null)
{
return(false);
}
count++;
SubeEnInsercion(t);
return(true);
}
private static NodoAvl GetMayorInterno(NodoAvl arbol)
{
if (arbol != null)
{
if (arbol.HijoIzq != null)
{
return(GetMayorInterno(arbol.HijoIzq));
}
else
{
return(arbol);
}
}
else
{
return(null);
}
}
/// <summary>
/// Devuelve el Nodo Despues que se inserto
/// </summary>
/// <param name="valor"></param>
/// <returns></returns>
private static NodoAvl AddInterno(NodoAvl arbol, T valor)
{
if (arbol != null)
{
int t = arbol.Valor.CompareTo(valor);
if (t < 0)
{
if (arbol.HijoIzq == null)
{
arbol.HijoIzq = new NodoAvl(valor);
arbol.HijoIzq.Padre = arbol;
return(arbol.HijoIzq);
}
else
{
return(AddInterno(arbol.HijoIzq, valor));
}
}
else if (t > 0)
{
if (arbol.HijoDercho == null)
{
arbol.HijoDercho = new NodoAvl(valor);
arbol.HijoDercho.Padre = arbol;
return(arbol.HijoDercho);
}
else
{
return(AddInterno(arbol.HijoDercho, valor));
}
}
else
{
return(null);
}
//no se modifican la altura y fb del padre
}
else
{
return(new NodoAvl(valor));
}
}
private IEnumerable <T> RecorreInOrderByLeft(NodoAvl arbol)
{
if (arbol.HijoIzq != null)
{
foreach (T var in RecorreInOrderByLeft(arbol.HijoIzq))
{
yield return(var);
}
}
yield return(arbol.Valor);
if (arbol.HijoDercho != null)
{
foreach (T var in RecorreInOrderByLeft(arbol.HijoDercho))
{
yield return(var);
}
}
}
public void vitacoraArbol(int valEquilibrio, string rotacionArbol, NodoAvl miArbol)
{
int contado = 0;
TextWriter escribirDato = new StreamWriter("Vitacora.txt", true);
string nuevo = ArbolAvl.rcPreorden(miArbol);
string[] palabras = nuevo.Split(',', ';');
string variable = "";
foreach (string palabra in palabras)
{
contado++;
if (palabra != "" && contado % 2 == 0)
{
variable = variable + " -- " + palabra;
}
}
escribirDato.WriteLine(variable + "-> " + rotacionArbol + "-> " + valEquilibrio);
escribirDato.Close();
}
private static bool EstaInterno(NodoAvl arbol, T valor)
{
if (arbol == null)
{
return(false);
}
else
{
int t = arbol.Valor.CompareTo(valor);
if (t < 0)
{
return(EstaInterno(arbol.HijoIzq, valor));
}
else if (t > 0)
{
return(EstaInterno(arbol.HijoDercho, valor));
}
else
{
return(true);
}
}
}
private static NodoAvl RotaDDD(NodoAvl r)
{
/* r
* \
* x
* \
* w
*/
NodoAvl x = r.HijoDercho;
r.HijoDercho = x.HijoIzq;
if (r.HijoDercho != null)
{
r.HijoDercho.Padre = r; //imp
}
x.HijoIzq = r;
x.Padre = r.Padre;
r.Padre = x;
if (x.Padre != null)
{
if (x.Valor.CompareTo(x.Padre.Valor) > 0)
{
x.Padre.HijoIzq = x;
}
else
{
x.Padre.HijoDercho = x;
}
}
r.ReCalcula();
x.ReCalcula();
if (x.Padre != null)
{
x.Padre.ReCalcula();
}
return(x);
}
private void SubeEnEliminacion(NodoAvl hijo)
{
NodoAvl t = hijo;
t.ReCalcula();
do
{
if (t.balPrev == 0 && (t.Balance == -1 || t.Balance == 1))
{
break;
}
else if (t.Balance == -2 || t.Balance == 2)
{
if (t.Balance == -2)
{
if (t.HijoIzq.Balance == 0)
{
t = RotaIII(t);
if (t.Padre == null)
{
raiz = t;
}
break;
}
else if (t.HijoIzq.Balance == -1)
{
t = RotaIII(t);
if (t.Padre == null)
{
raiz = t;
break;
}
t = t.Padre;
continue;//no tengo que recalcularlo pq lo hago en la rotacion
}
else if (t.HijoIzq.Balance == 1)
{
t = RotaIID(t);
if (t.Padre == null)
{
raiz = t;
break;
}
t = t.Padre;
continue;
}
}
else if (t.Balance == 2)
{
if (t.HijoDercho.Balance == 0)
{
t = RotaDDD(t);
if (t.Padre == null)
{
raiz = t;
}
break;
}
else if (t.HijoDercho.Balance == 1)
{
t = RotaDDD(t);
if (t.Padre == null)
{
raiz = t;
break;
}
t = t.Padre;
continue;
}
else if (t.HijoDercho.Balance == -1)
{
t = RotaDDI(t);
if (t.Padre == null)
{
raiz = t;
break;
}
t = t.Padre;
continue;
}
} //else
} //else bal=2 V bal=-2
else
{
if (t.Padre != null)
{
t = t.Padre;
t.ReCalcula();
}
else
{
break;
}
}
} while (true);
}
public ArbolAvl()
{
arbolRaiz = null;
}
public Avl()
{
count = 0;
raiz = null;
}
private NodoAvl EliminaRetornaNodoCritico(T item)
{
if (raiz == null)
{
throw new InvalidOperationException("Arbol vacio");
}
if (!Contains(item))
{
throw new InvalidOperationException("No se contiene el elemento");
}
count--;
NodoAvl toRet;
NodoAvl toDel = GetItemInterno(raiz, item);
if (toDel.HijoIzq == null && toDel.HijoDercho == null)
{
toRet = toDel.Padre;
if (toRet == null)
{
raiz = null; return(null);
}
else
{
int t = toDel.Valor.CompareTo(toDel.Padre.Valor);
if (t < 0)
{
toDel.Padre.HijoDercho = null;
}
else
{
toDel.Padre.HijoIzq = null;
}
toDel.Padre = null;
return(toRet);
}
}
else if ((toDel.HijoIzq == null && toDel.HijoDercho != null) || (toDel.HijoIzq != null && toDel.HijoDercho == null))
{
NodoAvl toDelHijo = toDel.HijoDercho == null ? toDel.HijoIzq : toDel.HijoDercho;
toRet = toDel.Padre;
if (toRet == null)
{
toDelHijo.Padre = null;
raiz = toDelHijo;
toDel.HijoDercho = null; toDel.HijoIzq = null;
return(toRet);
}
else
{
int t = toDel.Valor.CompareTo(toDel.Padre.Valor);
if (t < 0)
{
toDel.Padre.HijoDercho = toDelHijo;
toDelHijo.Padre = toDel.Padre;
toDel.Padre = null;
toDel.HijoDercho = null; toDel.HijoIzq = null;
return(toRet);
}
else
{
toDel.Padre.HijoIzq = toDelHijo;
toDelHijo.Padre = toDel.Padre;
toDel.Padre = null;
toDel.HijoDercho = null; toDel.HijoIzq = null;
return(toRet);
}
}//else del padre null
}
else
{
NodoAvl menorDeMayores = GetMenorInterno(toDel.HijoIzq);
if (menorDeMayores.HijoIzq == null)
{
toDel.Valor = menorDeMayores.Valor;
toRet = menorDeMayores.Padre;
if (menorDeMayores.Valor.CompareTo(menorDeMayores.Padre.Valor) < 0)
{
menorDeMayores.Padre.HijoDercho = null;
}
else
{
menorDeMayores.Padre.HijoIzq = null;
}
menorDeMayores.Padre = null;
return(toRet);
}
else
{
toDel.Valor = menorDeMayores.Valor;
toRet = menorDeMayores.Padre;
if (menorDeMayores.Valor.CompareTo(menorDeMayores.Padre.Valor) < 0)
{
menorDeMayores.Padre.HijoDercho = menorDeMayores.HijoIzq;
menorDeMayores.HijoIzq.Padre = menorDeMayores.Padre;
}
else
{
menorDeMayores.Padre.HijoIzq = menorDeMayores.HijoIzq;
menorDeMayores.HijoIzq.Padre = menorDeMayores.Padre;
}
menorDeMayores.Padre = null;
menorDeMayores.HijoIzq = null;
return(toRet);
}
}
}
private NodoAvl insertarAvl(NodoAvl raiz, Comparador dt, Logical h)
{
NodoAvl n1;
if (raiz == null)
{
raiz = new NodoAvl(dt);
h.enviarLogica(true);
}
else if (dt.firstIdMenor(raiz.valorNodo(), 0))
{
NodoAvl iz;
iz = insertarAvl((NodoAvl)raiz.subarbolIzq(), dt, h);
raiz.ramaIzq(iz);
//De verificar la rama izquierda en donde se insertara el nodo
if (h.valorLogico())//obtiene un dato para verificar si hay datos
{
switch (raiz.fe)
{
case 1:
raiz.fe = 0;
h.enviarLogica(false);
break;
case 0:
raiz.fe = -1;
break;
case -1: // aplicar rotación a la izquierda
n1 = (NodoAvl)raiz.subarbolIzq();
if (n1.fe == -1)
{
raiz = rotacionII(raiz, n1);
}
else
{
raiz = rotacionID(raiz, n1);
}
h.enviarLogica(false);
break;
}
}
}
else if (dt.firstIdMayor(raiz.valorNodo(), 0))
{
NodoAvl dr;
dr = insertarAvl((NodoAvl)raiz.subarbolDch(), dt, h);
raiz.ramaDch(dr);
if (h.valorLogico())
{
switch (raiz.fe)
{
case 1: // aplicar rotación a la derecha
n1 = (NodoAvl)raiz.subarbolDch();
if (n1.fe == +1)
{
raiz = rotacionDD(raiz, n1);
}
else
{
raiz = rotacionDI(raiz, n1);
}
h.enviarLogica(false);
break;
case 0:
raiz.fe = +1;
break;
case -1:
raiz.fe = 0;
h.enviarLogica(false);
break;
}
}
}
else
{
throw new Exception("No puede haber claves repetidas ");
}
return(raiz);
}
public void Clear()
{
raiz = null;
count = 0;
}
