bool EliminarRotaciones(NodoAVL <T5> nodoActual, int anteriorFactorBalance)
{
if (anteriorFactorBalance == 0 && (nodoActual.FactorBalance == -1 || nodoActual.FactorBalance == 1))
{
return(true);
}
else if (nodoActual.FactorBalance == -2 && nodoActual.HijoIzq.FactorBalance == 0)
{
if (this.raiz == nodoActual)
{
this.raiz = nodoActual.HijoIzq;
}
RotaDer(nodoActual.HijoIzq);
nodoActual.FactorBalance++;
nodoActual.Padre.FactorBalance++;
return(true);
}
else if (nodoActual.FactorBalance == 2 && nodoActual.HijoDer.FactorBalance == 0)
{
if (this.raiz == nodoActual)
{
this.raiz = nodoActual.HijoDer;
}
RotaIzq(nodoActual.HijoDer);
nodoActual.FactorBalance--;
nodoActual.Padre.FactorBalance--;
return(true);
}
this.RotacionesDesbalance(nodoActual);
return(false);
}
public NodoAVL(int dato)
{
this.dato = dato;
li = null;
ld = null;
altura = 0;
}
bool BuscaMenorMayor(NodoAVL <T5> nodoActual, out NodoAVL <T5> menorMayor)
{
menorMayor = nodoActual;
if (nodoActual == null)
{
return(true);
}
if (nodoActual.HijoIzq == null)
{
if (nodoActual.Padre.HijoIzq == nodoActual)
{
nodoActual.Padre.HijoIzq = nodoActual.HijoDer;
}
else if (nodoActual.Padre.HijoDer == nodoActual)
{
nodoActual.Padre.HijoDer = nodoActual.HijoIzq;
}
if (nodoActual.HijoDer != null)
{
nodoActual.HijoDer.Padre = nodoActual.Padre;
}
return(false);
}
if (BuscaMenorMayor(nodoActual.HijoIzq, out menorMayor))
{
return(true);
}
int anteriorFactorBalance = nodoActual.FactorBalance;
nodoActual.FactorBalance++;
return(EliminarRotaciones(nodoActual, anteriorFactorBalance));
}
public boolean ancestros(NodoAVL nodo, Object dato, Stack pila)
{
if (nodo.retornaDato() == dato)
{
return(true);
}
if (nodo.retornaLi() != null)
{
if (ancestros(nodo.retornaLi(), dato, pila))
{
pila.add(nodo.retornaLi().retornaDato());
return(true);
}
}
if (nodo.retornaLd() != null)
{
if (ancestros(nodo.retornaLd(), dato, pila))
{
pila.add(nodo.retornaLd().retornaDato());
return(true);
}
}
return(false);
}
private NodoAVL insertar(NodoAVL nodo, int dato)
{
if (nodo == null)
{
estadoProceso = 0;
NodoAVL x = new NodoAVL(dato);
x.asignaAltura(1);
return(x);
}
if (dato == (int)nodo.retornaDato())
{
estadoProceso = 1;
//print("Dato repetido");
return(nodo);
}
if (dato < (int)nodo.retornaDato())
{
nodo.asignaLi(insertar(nodo.retornaLi(), dato));
}
else
{
nodo.asignaLd(insertar(nodo.retornaLd(), dato));
}
nodo.asignaAltura(Math.Max(this.altura(nodo.retornaLi()), this.altura(nodo.retornaLd())) + 1);
nodo = resolverDesbalanceIns(dato, nodo);
return(nodo);
}
public NodoAVL(T6 valor, int factorBalance, NodoAVL <T6> hijoIzq, NodoAVL <T6> hijoDer, NodoAVL <T6> padre = null)
{
HijoDer = hijoDer;
HijoIzq = hijoIzq;
Padre = padre;
Valor = valor;
FactorBalance = factorBalance;
}
private int altura(NodoAVL nodo)
{
if (nodo == null)
{
return(-1);
}
return(nodo.retornaAltura());
}
private int retornaBalance(NodoAVL nodo)
{
if (nodo == null)
{
return(0);
}
return(altura(nodo.retornaLi()) - altura(nodo.retornaLd()));
}
NodoAVL <T5> BuscaMenorMayor(NodoAVL <T5> nodoActual)
{
if (nodoActual.HijoIzq == null)
{
return(nodoActual);
}
return(BuscaMenorMayor(nodoActual.HijoIzq));
}
public NodoAVL(T6 valor, int altura, NodoAVL <T6> hijoIzq, NodoAVL <T6> hijoDer, NodoAVL <T6> padre = null)
{
HijoDer = hijoDer;
HijoIzq = hijoIzq;
Padre = padre;
Valor = valor;
Altura = altura;
}
bool Insertar(NodoAVL <T5> nodoActual, T5 valor)
{
if (nodoActual.Valor.CompareTo(valor).Equals(0))
{
return(true);
}
else if (nodoActual.Valor.CompareTo(valor) > 0)
{
if (nodoActual.HijoIzq != null)
{
if (Insertar(nodoActual.HijoIzq, valor))
{
return(true);
}
nodoActual.Altura++;
// nodoActual.FactorBalance--;
// llamado a rotaciones
return(InsertarRotaciones(nodoActual));
}
else
{
nodoActual.HijoIzq = new NodoAVL <T5>(valor, 0, null, null, nodoActual);
// nodoActual.FactorBalance--;
if (nodoActual.HijoIzq != null && nodoActual.HijoDer != null)
{
return(true);
}
nodoActual.Altura++;
return(false);
}
}
else if (nodoActual.Valor.CompareTo(valor) < 0)
{
if (nodoActual.HijoDer != null)
{
if (Insertar(nodoActual.HijoDer, valor))
{
return(true);
}
nodoActual.Altura++;
// nodoActual.FactorBalance++;
// lamado a rotaciones
return(InsertarRotaciones(nodoActual));
}
else
{
nodoActual.HijoDer = new NodoAVL <T5>(valor, 0, null, null, nodoActual);
// nodoActual.FactorBalance++;
if (nodoActual.HijoIzq != null && nodoActual.HijoDer != null)
{
return(true);
}
nodoActual.Altura++;
return(false);
}
}
return(false);
}
/**
* Realiza una rotacion a la derecha desde un nodo ingresado como parametro
* que tiene un factor de balance superior a 1 o inferior a -1
*
* @param nodo nodo de la clase NodoAVL que tiene un factor de balance
* superior a 1 o inferior a -1
* @return La nueva raiz del subarbol.
*/
private NodoAVL retornaPredecesor(NodoAVL nodo)
{
NodoAVL predecesor = nodo;
while (predecesor.retornaLd() != null)
{
predecesor = predecesor.retornaLd();
}
return(predecesor);
}
public void Insertar(T5 valor)
{
this.Count++;
if (this.raiz == null)
{
this.raiz = new NodoAVL <T5>(valor, 0, null, null); return;
}
Insertar(this.raiz, valor);
}
/**
* Calcula las posiciones de los respectivos subárboles y de cada nodo que
* forma parte de ese subárbol, para conocer en que posición van a ir dibujados
* los rectángulos representativos del árbol de la expresión.
*/
private void calcularPosiciones()
{
tamañoSubArboles.Clear();
NodoAVL raiz = this.arbol.retornaRaiz();
if (raiz != null)
{
calcularTamañoSubarbol(raiz);
calcularPosicion(raiz, Int32.MaxValue, Int32.MaxValue, 0);
}
}
public String posOrden(NodoAVL raiz)
{
String linea = "";
if (raiz != null)
{
linea += posOrden(raiz.retornaLi());
linea += posOrden(raiz.retornaLd());
linea += " " + raiz.retornaDato() + " ";
}
return(linea);
}
public void PreOrder(NodoAVL <DatosArbol> Nodo)
{
if (Nodo.DatoNodoArbol != null)
{
ArbolEnOrden += "Id: " + Convert.ToString(Nodo.DatoNodoArbol.IdA) + ". Nombre Producto: " + Convert.ToString(Nodo.DatoNodoArbol.NombreA) + Convert.ToString("\n");
Farmacos orden = new Farmacos();
orden.Id = Nodo.DatoNodoArbol.IdA;
orden.Nombre = Nodo.DatoNodoArbol.NombreA;
Singleton.Instance.Recorrido.AddArtesanal(orden);
PreOrder(Nodo.izquierdo);
PreOrder(Nodo.derecho);
}
}
private NodoAVL rotacionALaIzq(NodoAVL nodo)
{
//print("Rotando a la izquierda");
NodoAVL tempNodoDer = nodo.retornaLd();
NodoAVL t = tempNodoDer.retornaLi();
tempNodoDer.asignaLi(nodo);
nodo.asignaLd(t);
nodo.asignaAltura(Math.Max(altura(nodo.retornaLi()), altura(nodo.retornaLd())) + 1);
tempNodoDer.asignaAltura(Math.Max(altura(tempNodoDer.retornaLi()), altura(tempNodoDer.retornaLd())) + 1);
return(tempNodoDer);
}
bool InsertarRotaciones(NodoAVL <T5> nodoActual) // reduce las constantes
{
if (nodoActual.FactorBalance == 0)
{
return(true);
}
else if (nodoActual.FactorBalance == -1 || nodoActual.FactorBalance == 1)
{
return(false);
}
return(RotacionesDesbalance(nodoActual));
}
private NodoAVL rotacionALaDer(NodoAVL nodo)
{
//print("Rotando a la derecha");
NodoAVL tempNodoIzq = nodo.retornaLi();
NodoAVL t = tempNodoIzq.retornaLd();
tempNodoIzq.asignaLd(nodo);
nodo.asignaLi(t);
nodo.asignaAltura(Math.Max(altura(nodo.retornaLi()), altura(nodo.retornaLd())) + 1);
tempNodoIzq.asignaAltura(Math.Max(altura(tempNodoIzq.retornaLi()), altura(tempNodoIzq.retornaLd())) + 1);
return(tempNodoIzq);
}
public bool Insertar(T5 valor)
{
if (this.raiz == null)
{
this.raiz = new NodoAVL <T5>(valor, 0, null, null); this.Count++; return(true);
}
int valorRetorno = Insertar(this.raiz, valor);
if (valorRetorno == 2)
{
return(false);
}
return(true);
}
public String ancestros(NodoAVL nodo, Object dato)
{
String linea = "";
Stack <Object> pila = new Stack <Object>();
if (!ancestros(nodo, dato, pila))
{
return("No existe el registro");
}
pila.add(nodo.retornaDato());
while (!pila.isEmpty())
{
linea += " " + pila.pop() + " ";
}
return(linea);
}
NodoAVL <T5> Miembro(T5 valor, NodoAVL <T5> nodoActual)
{
if (nodoActual.Valor.Equals(valor))
{
return(nodoActual);
}
else if (nodoActual.Valor.CompareTo(valor) < 0 && nodoActual.HijoDer != null)
{
return(Miembro(valor, nodoActual.HijoDer));
}
else if (nodoActual.Valor.CompareTo(valor) > 0 && nodoActual.HijoIzq != null)
{
return(Miembro(valor, nodoActual.HijoIzq));
}
return(null);
}
void ShowTree(NodoAVL <T5> nodoActual, int llamado)
{
for (int veces = 0; veces < llamado; veces++)
{
Console.Write("-");
}
Console.Write("(" + nodoActual.Valor + ")" + " " + nodoActual.FactorBalance);
Console.WriteLine();
if (nodoActual.HijoIzq != null)
{
this.ShowTree(nodoActual.HijoIzq, llamado + 1);
}
if (nodoActual.HijoDer != null)
{
this.ShowTree(nodoActual.HijoDer, llamado + 1);
}
}
private NodoAVL eliminar(NodoAVL nodo, int dato)
{
if (nodo == null)
{
estadoProceso = 1;
return(null);
}
if (dato < (int)nodo.retornaDato())
{
nodo.asignaLi(eliminar(nodo.retornaLi(), dato));
}
else if (dato > (int)nodo.retornaDato())
{
nodo.asignaLd(eliminar(nodo.retornaLd(), dato));
}
else
{
estadoProceso = 0;
if (nodo.retornaLi() == null && nodo.retornaLd() == null)
{
//print("eliminando hoja");
return(null);
}
if (nodo.retornaLi() == null)
{
//print("removiendo hijo derecho");
nodo = null;
return(nodo.retornaLd());
}
else if (nodo.retornaLd() == null)
{
//print("Removiendo hijo izquierdo");
nodo = null;
return(nodo.retornaLi());
}
//print("Removiendo con 2 hijos");
NodoAVL tempNodo = this.retornaPredecesor(nodo.retornaLi());
nodo.asignaDato(tempNodo.retornaDato());
nodo.asignaLi(eliminar(nodo.retornaLi(), (int)tempNodo.retornaDato()));
}
nodo.asignaAltura(Math.Max(this.altura(nodo.retornaLi()), this.altura(nodo.retornaLd())) + 1);
return(resolverDesbalanceDel(nodo));
}
/**
* Calcula el tamaño de cada subárbol y lo agrega al objeto tamañoSubArboles de la clase
* de tipo HashMap que va a contener la coleccion de todos los
* subárboles que contiene un arbol.
* @param n:Objeto de la clase NodoB <T> que se utiliza como
* referencia calcular el tamaño de cada subárbol.
* @return Vector3 con el tamaño de cada subárbol.
*/
private Vector3 calcularTamañoSubarbol(NodoAVL n)
{
if (n == null)
{
return(new Vector3(0, 0, 0));
}
Vector3 ld = calcularTamañoSubarbol(n.retornaLi());
Vector3 rd = calcularTamañoSubarbol(n.retornaLd());
float h = distPadreHijo + Math.Max(ld.y, rd.y);
float w = ld.x + distHijoHijo + rd.x;
Vector3 d = new Vector3(w, h);
tamañoSubArboles.Add(n, d);
return(d);
}
int MenoresQ(NodoAVL <T5> nodoActual, T5 valor)
{
if (nodoActual == null)
{
return(0);
}
if (nodoActual.Valor.Equals(valor))
{
return(nodoActual.CantidadIzq);
}
else if (nodoActual.Valor.CompareTo(valor) > 0)
{
return(MenoresQ(nodoActual.HijoIzq, valor));
}
else if (nodoActual.Valor.CompareTo(valor) < 0)
{
return(1 + nodoActual.CantidadIzq + MenoresQ(nodoActual.HijoDer, valor));
}
return(0);
}
public String recorridoDFS(NodoAVL nodo)
{
String linea = "", lineaAux = "";
if (!(nodo.retornaLi() == null))
{
linea += " " + (nodo.retornaDato()) + " ";
lineaAux += recorridoDFS(nodo.retornaLi());
}
else
{
linea += " " + (nodo.retornaDato()) + " ";
}
if (!(nodo.retornaLd() == null))
{
lineaAux += recorridoDFS(nodo.retornaLd());
}
return(linea + lineaAux);
}
public String recorridoBFS(NodoAVL nodo)
{
String linea = "";
Queue <NodoAVL> cola = new LinkedList();
cola.add(nodo);
while (!cola.isEmpty())
{
nodo = cola.remove();
linea += " " + nodo.retornaDato() + " ";
if (nodo.retornaLi() != null)
{
cola.add(nodo.retornaLi());
}
if (nodo.retornaLd() != null)
{
cola.add(nodo.retornaLd());
}
}
return(linea);
}
private NodoAVL resolverDesbalanceDel(NodoAVL nodo)
{
int factBalance = this.retornaBalance(nodo);
if (factBalance > 1)
{
if (this.retornaBalance(nodo.retornaLi()) < 0)
{
nodo.asignaLi(rotacionALaIzq(nodo.retornaLi()));
}
return(rotacionALaDer(nodo));
}
if (factBalance < -1)
{
if (this.retornaBalance(nodo.retornaLd()) > 0)
{
nodo.asignaLd(rotacionALaDer(nodo.retornaLd()));
}
return(rotacionALaIzq(nodo));
}
return(nodo);
}
int Altura(NodoAVL <T5> nodoActual)
{
if (nodoActual == null)
{
return(-1);
}
if (nodoActual.HijoIzq == null && nodoActual.HijoDer == null)
{
return(0);
}
int altura = 0;
if (nodoActual.FactorBalance > 0)
{
altura = Altura(nodoActual.HijoDer);
}
else
{
altura = Altura(nodoActual.HijoIzq);
}
return(altura + 1);
}
