public String Insertar(int dato)
{
string msj = "";
raiz = Insertar(dato, raiz, ref msj);
return(msj);
}
private NodoA Insertar(int dato, NodoA rz, ref string msj)
{
if (rz == null)
{
NodoA nuevo = new NodoA(dato);
rz = nuevo;
raiz = nuevo;
}
else
{
NodoA actual = rz;
if (actual.Dato > dato)
{
actual.Izq = Insertar(dato, actual.Izq, ref msj);
actual.Izq.Padre = actual;
}
if (actual.Dato < dato)
{
actual.Der = Insertar(dato, actual.Der, ref msj);
actual.Der.Padre = actual;
}
if (actual.Dato == dato)
{
msj = "No se puede insertar datos duplicados";
}
}
return(rz);
}
public bool compareNode(List <NodoA> listaNodo, NodoA actual)
{
bool cEq = false;
bool pEq = false;
float dC = 0;
float dP = 0;
if (listaNodo.Count == 0)
{
return(false);
}
foreach (NodoA n in listaNodo)
{
dC = calcDist(n.getCasilla(), actual.getCasilla());
if (dC == 0)
{
cEq = true;
}
dP = calcDist(n.getPadre(), actual.getPadre());
if (dP == 0)
{
pEq = true;
}
if (cEq && pEq)
{
return(true);
}
}
return(false);
}
//Relleno los costes de cada casilla con la info de sus estados
// Y relleno los costes heurísticos (Manhattan) de cada casilla sabiendo el destino
private void CrearNodoAs()
{
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
NodoA node = new NodoA();
int g = (int)estados[i, j] + 1;
if (g > 2)
{
node.noPasar = true;
node.g = 100000000; //Coste casilla
}
else
{
node.g = g; //Coste casilla
}
node.G = g;
node.Posicion = new Pos(i, j);
node.H = costManhattan(i, j); //Coste heurístico
tablero[i, j] = node;
}
}
}
public NodoA Busca(int dato, NodoA rz)
{
NodoA aux = null;
if (rz != null)
{
if (rz.Dato > dato)
{
aux = Busca(dato, rz.Izq);
}
else if (rz.Dato < dato)
{
aux = Busca(dato, rz.Der);
}
else if (rz.Dato == dato)
{
aux = rz;
}
}
else
{
aux = null;
}
return(aux);
}
public NodoA checkPosition(NodoA nodo, List <NodoA> nodos)
{
foreach (NodoA n in nodos)
{
if (n.getCasilla().getPosicionGrid()
== nodo.getCasilla().getPosicionGrid())
{
return(n);
}
}
return(null);
}
/**
* A* y métodos asociados
* */
protected List <NodoA> AStar(CasillaGrid actual, CasillaGrid goal, Dictionary <TipoCasilla, float> moveIndex)
{
//List<NodoA> cerrados = new List<NodoA>();
//List<NodoA> abiertos = new List<NodoA>();
Dictionary <Vector2, NodoA> cerrados = new Dictionary <Vector2, NodoA>();
Dictionary <Vector2, NodoA> abiertos = new Dictionary <Vector2, NodoA>();
CasillaGrid target = goal;
NodoA starter = new NodoA(actual, null, 0);
abiertos.Add(starter.getCasilla().getPosicionGrid(), starter);
while (abiertos.Count != 0)
{
NodoA bestNode = GetLowestCostNode(abiertos);
abiertos.Remove(bestNode.getCasilla().getPosicionGrid());
cerrados.Add(bestNode.getCasilla().getPosicionGrid(), bestNode);
if (bestNode.getCasilla().getPosicionGrid() == goal.getPosicionGrid())
{
ICollection <NodoA> camino = cerrados.Values;
return(ReconstructPath(camino));
}
List <NodoA> vecinos = Neighbours(bestNode.getCasilla(), moveIndex);
foreach (NodoA n in vecinos)
{
if (cerrados.ContainsKey(n.getCasilla().getPosicionGrid()))
{
continue;
}
float costeNodo = bestNode.g + EuclideanDistance(bestNode.getCasilla().getPosicionGrid(), n.getCasilla().getPosicionGrid()) + moveIndex[n.getCasilla().getTipoCasilla()];
n.g = +costeNodo;
n.h = EuclideanDistance(n.getCasilla().getPosicionGrid(), goal.getPosicionGrid());
n.setPadre(bestNode.getCasilla());
if (abiertos.ContainsKey(n.getCasilla().getPosicionGrid()))
{
continue;
}
abiertos.Add(n.getCasilla().getPosicionGrid(), n);
}
}
return(null);
}
private List <int> enOrden(NodoA rz)
{
if (rz.Izq != null)
{
enOrden(rz.Izq);
}
//MessageBox.Show(rz.Dato + " ");
inOrder.Add(rz.Dato);
if (rz.Der != null)
{
enOrden(rz.Der);
}
return(inOrder);
}
private void calculaCamino()
{
//Una vez tenemos los padres de cada nodo, creamos el camino
NodoA auxiliar = tablero[destino.i, destino.j];
camino.Add(auxiliar.Posicion);
do
{
auxiliar = auxiliar.padre;
camino.Add(auxiliar.Posicion);
} while (auxiliar.padre != auxiliar);
//Lo invertimos y lo devolvemos
camino.Reverse();
}
private List <int> PreOrden(NodoA rz)
{
//MessageBox.Show(rz.Dato + " ");
preOrder.Add(rz.Dato);
if (rz.Izq != null)
{
PreOrden(rz.Izq);
}
if (rz.Der != null)
{
PreOrden(rz.Der);
}
return(preOrder);
}
private List <int> PostOrden(NodoA rz)
{
if (rz.Izq != null)
{
PostOrden(rz.Izq);
}
if (rz.Der != null)
{
PostOrden(rz.Der);
}
//MessageBox.Show(rz.Dato + " ");
postOrder.Add(rz.Dato);
return(postOrder);
}
public NodoA GetLowest(List <NodoA> lista)
{
NodoA best = null;
float lowestCost = Mathf.Infinity;
foreach (NodoA n in lista)
{
if (n.f() < lowestCost)
{
best = n;
lowestCost = n.f();
}
}
return(best);
}
public Pila alaPila(NodoA nodo, Pila lapila)
{
if (nodo != null)
{
lapila.Push(nodo.Dato);
}
if (nodo.Izq != null)
{
alaPila(nodo.Izq, lapila);
}
if (nodo.Der != null)
{
alaPila(nodo.Der, lapila);
}
return(lapila);
}
public NodoA GetLowestCostNode(Dictionary <Vector2, NodoA> diccionario)
{
NodoA nodoCosteMinimo = null;
float costeMinimo = Mathf.Infinity;
ICollection <NodoA> nodos = diccionario.Values;
foreach (NodoA nodoActual in nodos)
{
if (nodoActual.f() < costeMinimo)
{
costeMinimo = nodoActual.f();
nodoCosteMinimo = nodoActual;
}
}
return(nodoCosteMinimo);
}
public List <NodoA> Neighbours(CasillaGrid casilla, Dictionary <TipoCasilla, float> moveIndex)
{
NodoA aux = null;
List <NodoA> listNodes = new List <NodoA>();
List <CasillaGrid> adyacentes = casilla.getAdyacentes();
foreach (CasillaGrid c in adyacentes)
{
if (moveIndex[c.getTipoCasilla()] == Mathf.Infinity)
{
continue;
}
aux = new NodoA(c, casilla, moveIndex[c.getTipoCasilla()]);
listNodes.Add(aux);
}
return(listNodes);
}
///Este es el método que resuelve el problema y devuelve una lista con todas las casillas por las que tiene que pasar
///desde el origen hasta el destino, utilizando el algoritmo A*
public Resolutor(int[,] estado, Pos posOrigen, Pos posDestino)
{
//Este será el camino que rellenaremos al final
camino = new List <Pos>();
tablero = new NodoA[10, 10];
estados = estado;
destino = posDestino;
origen = posOrigen;
//Cola de prioridad para los nodos adyacentes no checkeados
//Lista con los nodos ya vistos y por los que no hay que volver a pasar
List <NodoA> aCheckear = new List <NodoA>();
//List<NodoA> aCheckear = new List<NodoA>();
List <NodoA> vistos = new List <NodoA>();
CrearNodoAs();
//Cogemos la casilla inicial y se mete a la lista de no chequeados
NodoA inicio = tablero[origen.i, origen.j]; //
inicio.padre = inicio;
inicio.G = inicio.g = 0;
inicio.F = inicio.G + inicio.H;
aCheckear.Add(inicio);
bool encontrado = false;
while (aCheckear.Count > 0 && !encontrado)
{
//Cogemos el nodo de menor F de la lista, lo quitamos de ella y lo metemos en los ya checkeados
int pos = 0;
int valorMax = 10000000;
for (int i = 0; i < aCheckear.Count; i++)
{
if (aCheckear[i].F < valorMax)
{
valorMax = aCheckear[i].F;
pos = i;
}
}
NodoA actual = aCheckear[pos];
// NodoA actual = aCheckear.Dequeue();
aCheckear.Remove(actual);
vistos.Add(actual);
//Se miran los adyacentes y se les coloca el nodo actual como padre
//se les pone como valor G su valor actual sumado al de su padre y se calcula su nuevo F
foreach (Pair <int, int> dir in dirs)
{
//Comprobamos si el adyacente está en el tablero
Pos nuevaPos = new Pos(); nuevaPos.Set(actual.Posicion.i + dir.First, actual.Posicion.j + dir.Second);
if (dentroTablero(nuevaPos))
{
//Comprobamos si el adyacente ya está entre los vistos
if (!vistos.Contains(tablero[nuevaPos.i, nuevaPos.j]))
{
//Comprobamos si el adyacente es una casilla bloqueada
if (tablero[nuevaPos.i, nuevaPos.j].noPasar == true)
{
vistos.Add(tablero[nuevaPos.i, nuevaPos.j]);
}
//Si no lo es, calculamos sus nuevos valores y lo metemos en la lista de pendientes
else
{
//Comprobamos si es nuestro destino y si no, seguimos
if (isGoal(nuevaPos))
{
encontrado = true;
tablero[nuevaPos.i, nuevaPos.j].padre = actual;
}
else
{
//Miramos si es un camino menos costoso que el anterior
int nuevoG = actual.G + tablero[nuevaPos.i, nuevaPos.j].g;
if (nuevoG < tablero[nuevaPos.i, nuevaPos.j].G && aCheckear.Contains(tablero[nuevaPos.i, nuevaPos.j]))
{
tablero[nuevaPos.i, nuevaPos.j].G = nuevoG;
tablero[nuevaPos.i, nuevaPos.j].padre = actual;
}
else if (!aCheckear.Contains(tablero[nuevaPos.i, nuevaPos.j]))
{
tablero[nuevaPos.i, nuevaPos.j].padre = actual;
}
tablero[nuevaPos.i, nuevaPos.j].F = tablero[nuevaPos.i, nuevaPos.j].G + tablero[nuevaPos.i, nuevaPos.j].H;
aCheckear.Add(tablero[nuevaPos.i, nuevaPos.j]);
}
}
}
}
}
}
if (encontrado)
{
calculaCamino();
}
else
{
imposible = true;
}
}
//CONSTRUCTORES
public Tree()
{
raiz = null;
}
public void Borrar(int dato)
{
NodoA nodo = Busca(dato);
if (nodo == raiz)
{
if ((nodo.Izq == null) && (nodo.Der == null))
{
raiz = null;
}
else if ((nodo.Izq != null) && (nodo.Der == null))
{
raiz = nodo.Izq;
}
else if ((nodo.Izq == null) && (nodo.Der != null))
{
raiz = nodo.Der;
}
else if ((nodo.Izq != null) && (nodo.Der != null))
{
Pila miPila = new Pila();
miPila = alaPila(nodo, miPila);
raiz = null;
while (!miPila.PilaVacia())
{
int n;
if ((n = (Convert.ToInt32(miPila.Pop()))) != dato)
{
Insertar(n);
}
}
}
}
else if (nodo != raiz)
{
if (nodo.Izq == null && (nodo.Der == null))
{
if (nodo.Padre.Izq == nodo)
{
nodo.Padre.Izq = null;
}
else
{
nodo.Padre.Der = null;
nodo.Padre = null;
}
}
else if ((nodo.Izq != null && (nodo.Der == null)))
{
nodo.Izq.Padre = nodo.Padre;
if (nodo.Padre.Izq == nodo)
{
nodo.Padre.Izq = nodo.Izq;
}
else
{
nodo.Padre.Der = nodo.Izq;
}
}
else
{
if ((nodo.Izq == null) && (nodo.Der != null))
{
nodo.Der.Padre = nodo.Padre;
if ((nodo.Padre.Izq) == nodo)
{
nodo.Padre.Izq = nodo.Der;
}
else
{
nodo.Padre.Der = nodo.Der;
}
}
else
{
if ((nodo.Izq != null) && nodo.Der != null)
{
Pila miPila = new Pila();
miPila = alaPila(nodo, miPila);
if (nodo.Padre.Izq == nodo)
{
nodo.Padre.Izq = null;
}
else
{
nodo.Padre.Der = null;
}
while (!miPila.PilaVacia())
{
int n;
if ((n = Int32.Parse(miPila.Pop().ToString())) != dato)
{
Insertar(n);
}
}
}
}
}
}
//MessageBox.Show("Borrado exitoso");
}
public Tree(int dato)
{
NodoA nuevo = new NodoA(dato);
raiz = nuevo;
}
public NodoA Busca(int dato)
{
NodoA aux = Busca(dato, raiz);
return(aux);
}
