//método interno para realizar la operación
protected Nodo insertar(Nodo raizSub, Comparador dato) //COMO PARAMETROS RAIZ Y COMPARADOR
{
if (raizSub == null)
{
raizSub = new Nodo(dato); //Si es nulo no hay nada que comparar
//Si el dato es menor le decimos que lo inserte a la izquierda
}
else if (dato.menorQue(raizSub.valorNodo())) //SI ES MENOR QUE
{
Nodo iz; //Variable para nodo izquierdo
iz = insertar(raizSub.subarbolIzquierdo(), dato); //Insertando hacia la rama izquierda
raizSub.ramaIzdo(iz); //Tirandolo para la rama izquierda
//Si el dato es menor le decimos que lo inserte a la derecha
}
else if (dato.mayorQue(raizSub.valorNodo())) //SI ES MAYOR QUE
{
Nodo dr; //Variable para nodo derecho
dr = insertar(raizSub.subarbolDerecho(), dato); //Insertando hacia la rama derecha
raizSub.ramaDcho(dr); //Tirandolo para la rama derecha
}
else
{
// throw new Exception("Nodo duplicado");
Console.WriteLine($"duplicado!!!! {raizSub.valorNodo()}");
}
return(raizSub); //Retornando la raiz del subarbol
}
//método interno para realizar la operación
private Nodo insertar(Nodo raizSub, Comparador dato)
{
if (raizSub == null)
{
raizSub = new Nodo(dato);
}
else if (dato.menorQue(raizSub.valorNodo()))
{
Nodo iz;
iz = insertar(raizSub.subarbolIzquierdo(), dato);
raizSub.ramaIzdo(iz);
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
Nodo dr;
dr = insertar(raizSub.subarbolDerecho(), dato);
raizSub.ramaDcho(dr);
}
else
{
// throw new Exception("Nodo duplicado");
Console.WriteLine($"duplicado!!!! {raizSub.valorNodo()}");
}
return(raizSub);
}
private NodoAvl borrarAvl(NodoAvl r, Comparador clave,
Logical cambiaAltura) //throws Exception
{
if (r == null)
{
throw new Exception(" Nodo no encontrado ");
}
else if (clave.menorQue(r.valorNodo()))
{
NodoAvl iz;
iz = borrarAvl((NodoAvl)r.subarbolIzdo(), clave, cambiaAltura);
r.ramaIzdo(iz);
if (cambiaAltura.booleanValue())
{
r = equilibrar1(r, cambiaAltura);
}
}
else if (clave.mayorQue(r.valorNodo()))
{
NodoAvl dr;
dr = borrarAvl((NodoAvl)r.subarbolDcho(), clave, cambiaAltura);
r.ramaDcho(dr);
if (cambiaAltura.booleanValue())
{
r = equilibrar2(r, cambiaAltura);
}
}
else // Nodo encontrado
{
NodoAvl q;
q = r; // nodo a quitar del árbol
if (q.subarbolIzdo() == null)
{
r = (NodoAvl)q.subarbolDcho();
cambiaAltura.setLogical(true);
}
else if (q.subarbolDcho() == null)
{
r = (NodoAvl)q.subarbolIzdo();
cambiaAltura.setLogical(true);
}
else
{ // tiene rama izquierda y derecha
NodoAvl iz;
iz = reemplazar(r, (NodoAvl)r.subarbolIzdo(), cambiaAltura);
r.ramaIzdo(iz);
if (cambiaAltura.booleanValue())
{
r = equilibrar1(r, cambiaAltura);
}
}
q = null;
}
return(r);
}
protected Nodo eliminar(Nodo raizSub, Comparador dato)
{
if (raizSub == null)
{
throw new Exception("No hay nod para eliminar");
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
Nodo iz;
iz = eliminar(raizSub.subarbolIzquierdo(), dato);
raizSub.ramaIzquierda(iz);
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
Nodo dr;
dr = eliminar(raizSub.subarbolDerecho(), dato);
raizSub.ramaDerecha(dr);
}
else
{
Nodo q;
q = raizSub;
if (q.subarbolIzquierdo() == null)
{
raizSub = q.subarbolDerecho();
}
else if (q.subarbolDerecho() == null)
{
raizSub = q.subarbolIzquierdo();
}
else
{
q = reemplazar(q);
}
q = null;
}
return(raizSub);
}
//método interno para realizar la operación
protected Nodo eliminar(Nodo raizSub, Comparador dato) //Enviamos como parametro raizSub y dato
{
if (raizSub == null)
{
throw new Exception("No encontrado el nodo con la clave"); //Si es nulo no hay nada que eliminar y lanzamos una excepcion
//Si el dato es menor que
}
else if (dato.menorQue(raizSub.valorNodo()))
{
Nodo iz;
iz = eliminar(raizSub.subarbolIzquierdo(), dato); //Eliminamos la rama izquierda
raizSub.ramaIzdo(iz);
//Si el dato es mayor que
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
Nodo dr;
dr = eliminar(raizSub.subarbolDerecho(), dato); //Eliminamos la rama derecha
raizSub.ramaDcho(dr);
}
else // Nodo encontrado
{
Nodo q;
q = raizSub; // nodo a quitar del árbol
if (q.subarbolIzquierdo() == null) //Si no tiene valor en la izquierda
{
raizSub = q.subarbolDerecho(); //Agarramos la derecha
}
else if (q.subarbolDerecho() == null) //Si no tiene valor en la derecha
{
raizSub = q.subarbolIzquierdo(); //Agarramos el izquierda
//Si ninguno es nulo
}
else // tiene rama izquierda y derecha
{
q = reemplazar(q); //Lo reemplazamos
}
q = null; //De lo contrario q es igual a nulo
}
return(raizSub);
}
protected Nodo insertar(Nodo raizSub, Comparador dato)
{
if (raizSub == null)
{
raizSub = new Nodo(dato);
}
else if (dato.menorIgualQue(raizSub.valorNodo()))
{
Nodo iz;
iz = insertar(raizSub.subarbolIzquierdo(), dato);
raizSub.ramaIzquierda(iz);
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
Nodo dr;
dr = insertar(raizSub.subarbolDerecho(), dato);
raizSub.ramaDerecha(dr);
}
return(raizSub);
}//ef
public Nodo getNodo(Object n, Comparador cmp)
{
Nodo raizTmp = tree.raizArbol();
if (tree.esVacio())
{
return(null);
}
while (raizTmp.subarbolDcho() != null || raizTmp.subarbolIzdo() != null)
{
if (cmp.mayorQue(n))
{
if (raizTmp.subarbolDcho() != null)
{
raizTmp = raizTmp.subarbolDcho();
}
else
{
return(null);
}
}
else
{
if (raizTmp.subarbolIzdo() != null)
{
raizTmp = raizTmp.subarbolIzdo();
}
else
{
return(null);
}
}
if (cmp.igualQue(n))
{
return(raizTmp);
}
}
return(raizTmp);
}
//método interno para realizar la operación
protected Nodo eliminar(Nodo raizSub, Comparador dato)
{
if (raizSub == null)
{
throw new Exception("No encontrado el nodo con la clave");
}
else if (dato.menorQue(raizSub.valorNodo()))
{
Nodo iz;
iz = eliminar(raizSub.subarbolIzdo(), dato);
raizSub.ramaIzdo(iz);
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
Nodo dr;
dr = eliminar(raizSub.subarbolDcho(), dato);
raizSub.ramaDcho(dr);
}
else // Nodo encontrado
{
Nodo q;
q = raizSub; // nodo a quitar del árbol
if (q.subarbolIzdo() == null)
{
raizSub = q.subarbolDcho();
}
else if (q.subarbolDcho() == null)
{
raizSub = q.subarbolIzdo();
}
else
{ // tiene rama izquierda y derecha
q = reemplazar(q);
}
q = null;
}
return(raizSub);
}
protected Nodo eliminar(Nodo raizSub, Comparador dato)
{
if (raizSub == null)
{
throw new Exception("NO HAY NODO PARA ELIMINAR");
}
else if (dato.menorQue(raizSub.valorNodo()))
{
Nodo iz;
iz = eliminar(raizSub.subarbolIzquierdo(), dato);
raizSub.ramaIzquierda(iz);
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
Nodo dr;
dr = eliminar(raizSub.subarbolDerecho(), dato);
raizSub.ramaDerecha(dr);
}
else//nodo encontrado
{
Nodo q;
q = raizSub; //este es eo nodo que se quita del arbol
if (q.subarbolIzquierdo() == null)
{
raizSub = q.subarbolDerecho();
}
else if (q.subarbolDerecho() == null)
{
raizSub = q.subarbolIzquierdo();
}
else //tiene rama izquierda y derecha
{
q = reemplazar(q);
}
q = null;
}
return(raizSub);
}
protected nodo eliminar(nodo raizSub, Comparador dato)
{
if (raizSub == null)
{
throw new Exception("No hay nodo para eliminar");
}
else if (dato.menorQue(raizSub.valorNodo()))
{
nodo iz;
iz = eliminar(raizSub.subarbolIzquierdo(), dato);
raizSub.ramaIzquierda(iz);
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
nodo dr;
dr = eliminar(raizSub.subarbolDerecho(), dato);
raizSub.ramaDerecha(dr);
}
else
{
nodo q;
q = raizSub; //este es el nodo que se quita del árbol
if (q.subarbolIzquierdo() == null)
{
raizSub = q.subarbolDerecho();
}
else if (q.subarbolDerecho() == null)
{
raizSub = q.subarbolIzquierdo();
}
else// tiene rama izquierda y derecha
{
q = reemplazar(q);
}
q = null;
}
return(raizSub);
}//end eliminar
//método interno para realizar la operación
protected Nodo insertar(Nodo raizSub, Comparador dato)
{
if (raizSub == null)
{
raizSub = new Nodo(dato);
}
else if (dato.menorQue(raizSub.valorNodo()))
{
Nodo iz;
iz = insertar(raizSub.subarbolIzdo(), dato);
raizSub.ramaIzdo(iz);
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
Nodo dr;
dr = insertar(raizSub.subarbolDcho(), dato);
raizSub.ramaDcho(dr);
}
else
{
throw new Exception("Nodo duplicado");
}
return(raizSub);
}
private NodoAvl insertarAvl(NodoAvl raiz, Comparador dt, Logical h)
//throws Exception
{
NodoAvl n1;
if (raiz == null)
{
raiz = new NodoAvl(dt);
h.setLogical(true);
}
else if (dt.menorQue(raiz.valorNodo()))
{
NodoAvl iz;
iz = insertarAvl((NodoAvl)raiz.subarbolIzdo(), dt, h);
raiz.ramaIzdo(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.fe)
{
case 1:
raiz.fe = 0;
h.setLogical(false);
break;
case 0:
raiz.fe = -1;
break;
case -1: // aplicar rotación a la izquierda
n1 = (NodoAvl)raiz.subarbolIzdo();
if (n1.fe == -1)
{
raiz = rotacionII(raiz, n1);
}
else
{
raiz = rotacionID(raiz, n1);
}
h.setLogical(false);
break;
}
}
}
else if (dt.mayorQue(raiz.valorNodo()))
{
NodoAvl dr;
dr = insertarAvl((NodoAvl)raiz.subarbolDcho(), dt, h);
raiz.ramaDcho(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.fe)
{
case 1: // aplicar rotación a la derecha
n1 = (NodoAvl)raiz.subarbolDcho();
if (n1.fe == +1)
{
raiz = rotacionDD(raiz, n1);
}
else
{
raiz = rotacionDI(raiz, n1);
}
h.setLogical(false);
break;
case 0:
raiz.fe = +1;
break;
case -1:
raiz.fe = 0;
h.setLogical(false);
break;
}
}
}
else
{
throw new Exception("No puede haber claves repetidas ");
}
return(raiz);
}
private NodoAvl insertarDatoAvl(NodoAvl objRaizAvl, Comparador nuevoDato, Logical objLogico)
//throws Exception
{
NodoAvl n1;
if (objRaizAvl == null)
{
objRaizAvl = new NodoAvl(nuevoDato);
objLogico.setLogical(true);
}
else if (nuevoDato.menorQue(objRaizAvl.valorNodo()))
{
NodoAvl iz;
iz = insertarDatoAvl((NodoAvl)objRaizAvl.subArbolIzdo(), nuevoDato, objLogico);
objRaizAvl.ramaIzdo(iz);
// regreso por los nodos del camino de búsqueda
if (objLogico.booleanValue())
{
// decrementa el fe por aumentar la altura de rama izquierda
switch (objRaizAvl.fe)
{
case 1:
objRaizAvl.fe = 0;
objLogico.setLogical(false);
break;
case 0:
objRaizAvl.fe = -1;
break;
case -1: // aplicar rotación a la izquierda
n1 = (NodoAvl)objRaizAvl.subArbolIzdo();
if (n1.fe == -1)
{
objRaizAvl = rotacionII(objRaizAvl, n1);
}
else
{
objRaizAvl = rotacionID(objRaizAvl, n1);
}
objLogico.setLogical(false);
break;
}
}
}
else if (nuevoDato.mayorQue(objRaizAvl.valorNodo()))
{
NodoAvl dr;
dr = insertarDatoAvl((NodoAvl)objRaizAvl.subArbolDrcho(), nuevoDato, objLogico);
objRaizAvl.ramaDcho(dr);
// regreso por los nodos del camino de búsqueda
if (objLogico.booleanValue())
{
// incrementa el fe por aumentar la altura de rama izquierda
switch (objRaizAvl.fe)
{
case 1: // aplicar rotación a la derecha
n1 = (NodoAvl)objRaizAvl.subArbolDrcho();
if (n1.fe == +1)
{
objRaizAvl = rotacionDD(objRaizAvl, n1);
}
else
{
objRaizAvl = rotacionDI(objRaizAvl, n1);
}
objLogico.setLogical(false);
break;
case 0:
objRaizAvl.fe = +1;
break;
case -1:
objRaizAvl.fe = 0;
objLogico.setLogical(false);
break;
}
}
}
else
{
throw new Exception("No puede haber claves repetidas ");
}
return(objRaizAvl);
}
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);
}