private Orto <Unidad> ordenarNodo(Orto <Unidad> nodo_base)
{
Orto <Unidad> aux = nodo_base;
while (aux.bottom != null)
{
aux = aux.bottom;
}//ahora trabajo con el nodo mas bajo
//y me voy de regreso para arreglar
while (aux.top != null)
{
if (aux.Item.Nivel_z == 1)//si es un barco, ese se queda como el principal
{
break;
}
else if (aux.Item.Nivel_z == 2)
{
break;
}
aux = aux.top;
}//si al final no habia barco, por defecto el nivel de avion, luego el de satelite, si solo hay submarino ese queda
aux.up = nodo_base.up;
nodo_base.up.down = aux;
aux.izq = nodo_base.izq;
nodo_base.izq.der = aux;
return(aux);
}
public bool insertar(Unidad item)//insertar principal
{
Unidad auxiliar = buscarPorPosicion(item.Fila_y, item.Col_x, item.Nivel_z);
if (auxiliar != null) //si ya hay algo en ese espacio
{
return(false); //regreso false y no hago nada mas
}
NodoAux <Orto <Unidad> > row = buscarRow(item.Fila_y);
NodoAux <Orto <Unidad> > col = buscarCol(item.Col_x);
if (row == null)
{
addRow(item.Fila_y);
row = buscarRow(item.Fila_y);//en teoria ya no deberia ser null en este punto
}
if (col == null)
{
addColumn(item.Col_x);
col = buscarCol(item.Col_x);//en teoria ya no deberia ser null en este punto
}
Orto <Unidad> aux = insertarEnColumna(col.item, col.item.down, item, item.Fila_y, item.Col_x);
if (aux == null) //el espacio esta ocupado
{
return(false); //esto ya no deberia ocurrir gracias a la inclusion de buscar, pero de todas formas
}//en caso de un error podria llegar aqui y es mejor que regrese false a que tire una excepcion
insertarEnFila(row.item, row.item.der, aux);
return(true);
}
private Orto <Unidad> buscarZ(int z, Orto <Unidad> raiz)
{
Orto <Unidad> aux = raiz;
while (aux.bottom != null)
{
aux = aux.bottom;
}
while (aux != null)
{
if (aux.Item.Nivel_z == z)
{
break;
}
aux = aux.top;
}
if (aux == null)
{
return(null);
}
if (aux.Item.Nivel_z == z)
{
return(aux);
}
return(null);//si no lo encuentra
}
private Orto <Unidad> insertarEnColumna(Orto <Unidad> actual, Orto <Unidad> down, Unidad item, int fila, string columna)
{
if (down == null)
{
actual.down = new Orto <Unidad>(item);
actual.down.up = actual;
return(actual.down);
}
else if (columna.CompareTo(down.Item.Col_x) < 0) //va arriba de down y abajo de actual
{
actual.down = new Orto <Unidad>(item); //actual apunta a nuevo
actual.down.up = actual; //nuevo apunta a actual
actual.down.down = down; //nuevo apunta a down
down.up = actual.down; //down apunta a nuevo
return(actual.down);
}
else if (columna.CompareTo(down.Item.Col_x) > 0)
{
return(insertarEnColumna(down, down.down, item, fila, columna));//sigo buscando donde va
}
else
{
if (fila < down.Item.Fila_y)
{
actual.down = new Orto <Unidad>(item); //actual apunta a nuevo
actual.down.up = actual; //nuevo apunta a actual
actual.down.down = down; //nuevo apunta a down
down.up = actual.down; //down apunta a nuevo
return(actual.down);
}
else if (fila > down.Item.Fila_y)
{
return(insertarEnColumna(down, down.down, item, fila, columna));//sigo buscando donde
}
else//codigo para insertar en diferente nivel
{
if (down.Item.Nivel_z > item.Nivel_z)//si el que esta actualmente en el nodo, va arriba del nuevo
{
down.bottom = new Orto <Unidad>(item);
down.bottom.top = down;
return(ordenarNodo(down));
}
else if (down.Item.Nivel_z < item.Nivel_z)//el que esta actualmente en el nodo, va debajo del nuevo
{
down.top = new Orto <Unidad>(item);
down.top.bottom = down;
return(ordenarNodo(down));
}
else
{
return(null);//el espacio esta ocupado por otra unidad
}
}
}
}
public Unidad buscarPorPosicion(int fila, string columna, int z)
{
NodoAux <Orto <Unidad> > row = buscarRow(fila);
if (row != null)//si la fila existe es porque mínimo hay un nodo en esa fila
{
//NodoO aux = buscarUnidad(row.item, row.item.der, fila, columna);
Orto <Unidad> aux = buscarNodoUnidad(row.item.der, row.item.der.der, fila, columna);
if (aux == null)//si no se encontro algo en fila,columna
{
return(null);
}
aux = buscarZ(z, aux);
if (aux != null)//si se encontro algo en fila, columna, z
{
return(aux.Item);
}
}
return(null);//si no encontro el valor
}
private static Orto <Unidad> buscarZ(int z, Orto <Unidad> raiz)
{
if (raiz == null)
{
return(null);
}
Orto <Unidad> aux = raiz;
while (aux.bottom != null)
{
aux = aux.bottom;
}
while (aux != null)
{
if (aux.Item.Nivel_z == z)
{
break;
}
aux = aux.top;
}
return(aux);
}
private void insertarEnFila(Orto <Unidad> actual, Orto <Unidad> der, Orto <Unidad> nuevo)
{
if (der == null)
{
actual.der = nuevo;
nuevo.izq = actual;
}
else if (nuevo.Item.Fila_y < der.Item.Fila_y) //va izq de der y der de actual
{
actual.der = nuevo; //actual apunta a nuevo
nuevo.izq = actual; //nuevo apunta a actual
nuevo.der = der; //nuevo apunta a down
der.izq = nuevo; //down apunta a nuevo
}
else if (nuevo.Item.Fila_y > der.Item.Fila_y)
{
insertarEnFila(der, der.der, nuevo);
}
else
{
if (nuevo.Item.Col_x.CompareTo(der.Item.Col_x) < 0)
{
actual.der = nuevo; //actual apunta a nuevo
nuevo.izq = actual; //nuevo apunta a actual
nuevo.der = der; //nuevo apunta a down
der.izq = nuevo; //down apunta a nuevo
}
else if (nuevo.Item.Col_x.CompareTo(der.Item.Col_x) > 0)
{
insertarEnFila(der, der.der, nuevo);
}
else
{
//insertar columna se encarga de Z
}
}
}
private Orto <Unidad> buscarNodoUnidad(Orto <Unidad> actual, Orto <Unidad> siguiente, int fila, string columna)
{
if (actual == null)//si llegue al final sin encotrarlo
{
return(null);
}
else if (actual.Item.Col_x.CompareTo(columna) < 0)//si el valor en el que voy es menor que el que me piden
{
if (siguiente == null)
{
return(null);
}
return(buscarNodoUnidad(siguiente, siguiente.der, fila, columna)); //sigo buscando
}
else if (actual.Item.Col_x.Equals(columna)) //si es igual
{
return(actual); //lo retorno
}
else//si es mayor, ya me pase, no existe
{
return(null);//retorno null
}
//return null;
}
private static string codigoNodos(NodoAux <Orto <Unidad> > fila, int nivel, bool vivo)
{
string salida = "";
NodoAux <Orto <Unidad> > aux = fila;
Orto <Unidad> actual;
Orto <Unidad> actual_Z;
while (aux != null)
{
actual = aux.item;
actual = actual.der;//el primero es la raiz y ese no tiene nada
salida += "{rank=same;\n";
while (actual != null)
{
actual_Z = buscarZ(nivel, actual); //este seria el nodo en el nivel que estoy buscando
if (actual_Z != null && actual_Z.Item.Vivo == vivo) //si hay algo en ese nivel, y es el estado que quiero
{
Unidad coso = actual_Z.Item;
salida += "orto" + coso.Fila_y + "_" + coso.Col_x
+ "[label=\"" + coso.Tipo + "\nVida:" + coso.Hp + "\nMov:" + coso.Movimiento
+ "\nRango:" + coso.Alcance + "\";shape=box;height=.7;width=.7;fixedsize=true;fontsize=8];\n";
if (actual.izq.Item == null)//apunta a la raiz que esta dentro de la fila, necesito usar a nodo raiz, no a nodo Z
{
salida += "row" + aux.Key + "->orto" + coso.Fila_y + "_" + coso.Col_x + "[dir=both;weight=0];\n";
}
if (actual.izq.Item != null) //apunta a una unidad
{
Orto <Unidad> companyero_izq = buscarZ(nivel, actual.izq); //busco a ver si tiene un compañero
if (companyero_izq != null && companyero_izq.Item.Vivo == vivo) //el codigo no necesita que lo haga con actual Z o companyero, eso da igual
{
salida += "orto" + actual.izq.Item.Fila_y + "_" + actual.izq.Item.Col_x + "->orto" + coso.Fila_y + "_" + coso.Col_x + "[dir=both;weight=0];\n";
}
}
}
actual = actual.der;
}
salida += "}\n";
actual = aux.item;
actual = actual.der; //el primero es la raiz y ese no tiene nada
while (actual != null) //columnas
{
actual_Z = buscarZ(nivel, actual); //para terminar, con las columnas
if (actual_Z != null)
{
Unidad coso = actual_Z.Item;
if (actual.up.Item != null) //no es la raiz
{
Orto <Unidad> companyero_izq = buscarZ(nivel, actual.up); //busco a ver si tiene un compañero
salida += "orto" + actual.up.Item.Fila_y + "_" + actual.up.Item.Col_x + "->orto" + actual.Item.Fila_y + "_" + actual.Item.Col_x + "[dir=both];\n";
}
else// (actual.up.item == null)
{
salida += "col" + actual.Item.Col_x + "->orto" + actual.Item.Fila_y + "_" + actual.Item.Col_x + "[dir=both];\n";
}
}
actual = actual.der;
}
salida += "\n";
aux = aux.siguiente;
}
return(salida);
}
private Unidad buscarEnZ(string duenyo, string nombre_unidad, Orto <Unidad> pivote, bool sacar)
{
Orto <Unidad> aux = pivote;
while (aux.bottom != null)//voy hasta el fondo
{
aux = aux.bottom;
}
while (aux != null)//y busco hacia arriva
{
if (aux.Item.Duenyo.Equals(duenyo) && aux.Item.Nombre.Equals(nombre_unidad))
{
if (!sacar)//si no lo quiero sacar solo muestro el item, sin sacarlo del nodo
{
return(aux.Item);
}
else
{
break;
}
}
//return aux.Item;
aux = aux.top;
}
if (aux == null)
{
return(null);
}
else//si aux no es null, significa que en este punto yo quiero quitar la unidad de ahi
{
Unidad item = aux.Item;//recupero el item
if (aux.der == null && aux.izq == null && aux.up == null && aux.down == null) //si no es el nodo raiz en Z
{
if (aux.bottom == null) //si es el ultimo de abajo a arriba
{
//item = aux.Item;
aux.top.bottom = null;
return(item);
}
else if (aux.top == null) //es el ultimo de arriba a abajo
{
// item = aux.Item;
aux.bottom.top = null;
return(item);
}
else //esta en medio
{
//item = aux.Item;
aux.bottom.top = aux.top; //bottom apunta al top de aux
aux.top.bottom = aux.bottom; //top apunta al bottom de aux
return(item);
}
}
else if (aux.top != null || aux.bottom != null) //el nodo no queda vacio luego de la extraccion
{
if (aux.top != null) //como prioridad establecemos a top como la nueva raiz en Z
{
//item = aux.Item;//recupero el item
if (aux.top.top == null) //si ya no hay nada mas arriba
{
aux.Item = aux.top.Item; //muevo el item de arriba hacia aqui, asi no tengo que reacomodar los punteros
aux.top = null; //elimino el nodo vacio
}
else
{
aux.Item = aux.top.Item; //muevo el item de arriba aqui
aux.top.Item = aux.top.top.Item; //muevo el item de arriba arriba aqui
aux.top.top = null; //elimino el nodo vacio
}
}
else
{
//item = aux.Item;//recupero el item
if (aux.bottom.bottom == null) //si no hay nada mas abajo
{
aux.Item = aux.bottom.Item; //muevo el item de abajo aqui
aux.bottom = null; //elimino el nodo de abajo
}
else
{
aux.Item = aux.bottom.Item; //muevo el item de abajo aqui
aux.bottom.Item = aux.bottom.bottom.Item; //muevo el item de abajo abajo aqui
aux.bottom.bottom = null; //elimino el nodo vacio
}
}
}
else //si no queda nada despues de la extraccion
{
if (aux.up.Item == null && aux.down == null)//si la columna queda vacia(aux.up.item==null es porque la raiz siempre tiene item nulo)
{
eliminarColumna(item.Col_x); //elimino la columna
}
if (aux.izq.Item == null && aux.der == null) //si la fila queda vacia(aux.izq.item==null es porque la raiz siempre tiene item nulo)
{
eliminarFila(item.Fila_y);
}
aux.up.down = aux.down;//recupero los punteros de arriba y abajo
if (aux.down != null)
{
aux.down.up = aux.up;
}//termino de recuperar los punteros de arriba y abajo
aux.izq.der = aux.der;//recupero los punteros de izq y derecha
if (aux.der != null)
{
aux.der.izq = aux.izq;
}//termino de recuperar los punteros de izq y derecha
}
return(item);
}
}
