Beispiel #1
0
        public List <Lugar> ObtenerVerticesAyacentes(string pNombreVertice)
        {
            Lista <Vertice <Lugar> > ListaAyacentes = Grafo.GetListaSucesores(pNombreVertice);

            if (ListaAyacentes != null)
            {
                List <Lugar> ListaLugaresAyacentes   = new List <Lugar>();
                Iterador <Vertice <Lugar> > iterador = new Iterador <Vertice <Lugar> >(ListaAyacentes.GetCabeza());
                for (Vertice <Lugar> verticeAdyac = iterador.Next(); verticeAdyac != null; verticeAdyac = iterador.Next())
                {
                    ListaLugaresAyacentes.Add(verticeAdyac.Info);
                }

                return(ListaLugaresAyacentes);
            }
            Console.WriteLine("No se encontraron vertices ayacentes para el vertice " + pNombreVertice + " !");
            return(null);
        }
Beispiel #2
0
        private Lista <Vertice <T> > GetCaminoMinimo(TablaHash <string, int> pVerticesFinales, string pVerticeDestino)
        {
            Lista <Vertice <T> > ListaCaminoCorto = new Lista <Vertice <T> >();

            ListaCaminoCorto.InsertarAlInicio(this.GetVerticePorNombre(pVerticeDestino));
            Lista <Vertice <T> >    ListaSucesores = this.GetListaSucesores(pVerticeDestino);
            Iterador <Vertice <T> > iterador       = new Iterador <Vertice <T> >(ListaSucesores.GetCabeza());
            Vertice <T>             verticeActual  = this.GetVerticePorNombre(pVerticeDestino);
            Arista <T> arco = null;
            int        pesoA, pesoB, pesoC, residuo;
            bool       noSalir = true;

            while (noSalir)
            {
                for (Vertice <T> verticeAdyac = iterador.Next(); verticeAdyac != null; verticeAdyac = iterador.Next())
                {
                    arco = GetArco(verticeActual.Nombre, verticeAdyac.Nombre);
                    if (arco != null)
                    {
                        pesoA   = (int)arco.GetPeso();
                        pesoB   = pVerticesFinales.BuscaHashPorClave(verticeActual.Nombre);
                        pesoC   = pVerticesFinales.BuscaHashPorClave(verticeAdyac.Nombre);
                        residuo = pesoB - pesoA;
                        if (residuo == pesoC || residuo == 0)
                        {
                            ListaCaminoCorto.InsertarAlInicio(arco.GetVertB());
                            verticeActual = verticeAdyac;
                            verticeAdyac  = null;
                            if (residuo == 0)
                            {
                                noSalir = false;
                            }
                        }
                    }
                }
                ListaSucesores = this.GetListaSucesores(verticeActual.Nombre);
                iterador       = new Iterador <Vertice <T> >(ListaSucesores.GetCabeza());
            }

            return(ListaCaminoCorto);
        }
Beispiel #3
0
 public List <Lugar> GetRutaMinimaDijkstra(string pNombreVerticeA, string pNombreVerticeB)
 {
     try
     {
         Lista <Vertice <Lugar> > ListaCaminoMinimo = Grafo.RutaMinimaDijkstra(pNombreVerticeA, pNombreVerticeB);
         if (ListaCaminoMinimo != null)
         {
             List <Lugar> ListaLugares            = new List <Lugar>();
             Iterador <Vertice <Lugar> > iterador = new Iterador <Vertice <Lugar> >(ListaCaminoMinimo.GetCabeza());
             for (Vertice <Lugar> verticeAdyac = iterador.Next(); verticeAdyac != null; verticeAdyac = iterador.Next())
             {
                 ListaLugares.Add(verticeAdyac.Info);
             }
             return(ListaLugares);
         }
     }
     catch (Exception e)
     {
         Console.WriteLine(e.Message);
     }
     return(null);
 }
Beispiel #4
0
 public Lista <Vertice <T> > RutaMinimaDijkstra(string pNombreVerticeA, string pNombreVerticeB)
 {
     if (pNombreVerticeA != pNombreVerticeB && !EsDirigido)
     {
         if (this.HayPesosNegativosEnArcos())
         {
             throw new Exception("Existe algun valor negativo en el peso de los arcos");
         }
         TablaHash <String, int> costosFinales    = GetTablasHashParaDijkstra();
         TablaHash <String, int> costosTemporales = GetTablasHashParaDijkstra();
         string clave = null;
         this.LimpiaVisitasVertices();
         Lista <Vertice <T> > ListaAuxiliarDSucesores, ListaSucesores = this.GetListaSucesores(pNombreVerticeA);
         Vertice <T>          verticeActual = this.GetVerticePorNombre(pNombreVerticeA);
         verticeActual.EsVisit = true;
         Arista <T> arco = null;
         int        peso = 0, costo = 0;
         Iterador <Vertice <T> > iterador = new Iterador <Vertice <T> >(ListaSucesores.GetCabeza());
         bool noSalir = true;
         costosTemporales.ActualizarDatoPorClave(pNombreVerticeA, 0);
         costosFinales.ActualizarDatoPorClave(pNombreVerticeA, 0);
         while (noSalir)
         {
             for (Vertice <T> verticeAdyac = iterador.Next(); verticeAdyac != null; verticeAdyac = iterador.Next())
             {
                 arco = GetArco(verticeActual.Nombre, verticeAdyac.Nombre);
                 if (arco != null)
                 {
                     costo = (int)arco.GetPeso() + peso;
                     if (costosTemporales.BuscaHashPorClave(arco.GetVertB().Nombre) > costo || costosTemporales.BuscaHashPorClave(arco.GetVertB().Nombre) == -1)
                     {
                         costosTemporales.ActualizarDatoPorClave(arco.GetVertB().Nombre, costo);
                     }
                 }
             }
             int index = -1, auxiliar = 0;
             clave = null;
             for (int i = 0; i < costosTemporales.GetTamanio(); i++)
             {
                 clave = costosTemporales.GetClave(i);
                 if ((auxiliar == 0 || auxiliar > costosTemporales.GetForIndex(i)) && (costosTemporales.GetForIndex(i) >= 0 && clave != null))
                 {
                     if (!ArregloDVertices.BuscaHashPorClave(clave).EsVisit)
                     {
                         auxiliar = costosTemporales.GetForIndex(i);
                         index    = i;
                     }
                 }
             }
             if (index != -1)
             {
                 clave = costosTemporales.GetClave(index);
                 costosFinales.ActualizarDatoPorIndex(index, auxiliar);
                 verticeActual         = ArregloDVertices.BuscaHashPorClave(clave);
                 verticeActual.EsVisit = true;
             }
             else
             {
                 if (DetenerAnalisis())
                 {
                     noSalir = false;
                 }
             }
             ListaAuxiliarDSucesores = this.GetListaSucesoresNoVisitados(clave);
             if (ListaAuxiliarDSucesores.GetCabeza() != null)
             {
                 ListaSucesores = ListaAuxiliarDSucesores;
             }
             peso     = auxiliar;
             index    = -1;
             auxiliar = 0;
             iterador = new Iterador <Vertice <T> >(ListaSucesores.GetCabeza());
         }
         Lista <Vertice <T> > ListaCaminoCorto = GetCaminoMinimo(costosFinales, pNombreVerticeB);
         return(ListaCaminoCorto);
     }
     return(null);
 }