예제 #1
0
        public String Insertar(int dato)
        {
            string msj = "";

            raiz = Insertar(dato, raiz, ref msj);
            return(msj);
        }
예제 #2
0
 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);
 }
예제 #3
0
    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);
    }
예제 #4
0
    //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;
            }
        }
    }
예제 #5
0
        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);
        }
예제 #6
0
    public NodoA checkPosition(NodoA nodo, List <NodoA> nodos)
    {
        foreach (NodoA n in nodos)
        {
            if (n.getCasilla().getPosicionGrid()
                == nodo.getCasilla().getPosicionGrid())
            {
                return(n);
            }
        }

        return(null);
    }
예제 #7
0
    /**
     * 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);
    }
예제 #8
0
 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);
 }
예제 #9
0
    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();
    }
예제 #10
0
        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);
        }
예제 #11
0
        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);
        }
예제 #12
0
    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);
    }
예제 #13
0
 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);
 }
예제 #14
0
    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);
    }
예제 #15
0
    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);
    }
예제 #16
0
    ///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;
        }
    }
예제 #17
0
 //CONSTRUCTORES
 public Tree()
 {
     raiz = null;
 }
예제 #18
0
        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");
        }
예제 #19
0
        public Tree(int dato)
        {
            NodoA nuevo = new NodoA(dato);

            raiz = nuevo;
        }
예제 #20
0
        public NodoA Busca(int dato)
        {
            NodoA aux = Busca(dato, raiz);

            return(aux);
        }