Ejemplo n.º 1
0
        private bool Enlazar(NodoL <T> cabeza, ListD <T> lista)
        {
            bool result = false;

            if (cabeza.GetSig() is null)
            {
                cabeza.SetSig(lista.GetCabeza());
                result = true;
            }
            else
            {
                result = Enlazar(cabeza.GetSig(), lista);
            }
            return(result);
        }
Ejemplo n.º 2
0
        public ListD <Vertex <T> > GetListPreSuce(string pVertice)
        {
            int index = VerticesGroup.GetIndex(pVertice);

            if (index >= 0)
            {
                ListD <Vertex <T> > ListVerticesPreSuc = new ListD <Vertex <T> >();
                for (int i = 0; i < AdjacencMatrix.GetLength(1); i++)
                {
                    if (AdjacencMatrix[index, i] != null)
                    {
                        ListVerticesPreSuc.InsertarAlFinal(AdjacencMatrix[i, index].GetVertA());
                    }
                }
                return(ListVerticesPreSuc);
            }
            return(null);
        }
Ejemplo n.º 3
0
        public List <Place> ObtenerVerticesAyacentes(string pNombreVertice)
        {
            ListD <Vertex <Place> > ListaAyacentes = Graph.GetListaSuccessors(pNombreVertice);

            if (ListaAyacentes != null)
            {
                List <Place> ListaLugaresAyacentes  = new List <Place>();
                Iterator <Vertex <Place> > iterador = new Iterator <Vertex <Place> >(ListaAyacentes.GetCabeza());
                for (Vertex <Place> 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);
        }
Ejemplo n.º 4
0
        private ListD <Vertex <T> > GetListSuccessorNotVisited(string pVertice)
        {
            int index = VerticesGroup.GetIndex(pVertice);

            if (index >= 0)
            {
                ListD <Vertex <T> > ListVerticesSuce = new ListD <Vertex <T> >();
                for (int i = 0; i < AdjacencMatrix.GetLength(1); i++)
                {
                    if (AdjacencMatrix[index, i] != null && !AdjacencMatrix[index, i].GetVertB().IsVisit)
                    {
                        ListVerticesSuce.InsertarAlFinal(AdjacencMatrix[index, i].GetVertB());
                    }
                }
                return(ListVerticesSuce);
            }
            return(null);
        }
Ejemplo n.º 5
0
        public ListD <Vertex <T> > GetListaSuccessors(string pVertice)
        {
            int index = VerticesGroup.GetIndex(pVertice);

            if (index >= 0)
            {
                ListD <Vertex <T> > ListVerticesSuccessors = new ListD <Vertex <T> >();
                for (int i = 0; i < AdjacencMatrix.GetLength(1); i++)
                {
                    if (AdjacencMatrix[index, i] != null)
                    {
                        ListVerticesSuccessors.InsertarAlFinal(AdjacencMatrix[index, i].GetVertB());
                    }
                }
                return(ListVerticesSuccessors);
            }
            return(null);
        }
Ejemplo n.º 6
0
        private ListD <Vertex <T> > GetCaminoMinimo(HashTable <string, int> pVerticesFinales, string pVerticeDestino)
        {
            ListD <Vertex <T> > ListaCaminoCorto = new ListD <Vertex <T> >();

            ListaCaminoCorto.InsertarAlInicio(this.GetVertexByName(pVerticeDestino));
            ListD <Vertex <T> >    ListaSucesores = this.GetListaSuccessors(pVerticeDestino);
            Iterator <Vertex <T> > iterador       = new Iterator <Vertex <T> >(ListaSucesores.GetCabeza());
            Vertex <T>             verticeActual  = this.GetVertexByName(pVerticeDestino);
            Edge <T> arco = null;
            int      pesoA, pesoB, pesoC, residuo;
            bool     noSalir = true;

            while (noSalir)
            {
                for (Vertex <T> verticeAdyac = iterador.Next(); verticeAdyac != null; verticeAdyac = iterador.Next())
                {
                    arco = GetEdge(verticeActual.Name, verticeAdyac.Name);
                    if (arco != null)
                    {
                        pesoA   = (int)arco.GetWeight();
                        pesoB   = pVerticesFinales.SearchByKey(verticeActual.Name);
                        pesoC   = pVerticesFinales.SearchByKey(verticeAdyac.Name);
                        residuo = pesoB - pesoA;
                        if (residuo == pesoC || residuo == 0)
                        {
                            ListaCaminoCorto.InsertarAlInicio(arco.GetVertB());
                            verticeActual = verticeAdyac;
                            verticeAdyac  = null;
                            if (residuo == 0)
                            {
                                noSalir = false;
                            }
                        }
                    }
                }
                ListaSucesores = this.GetListaSuccessors(verticeActual.Name);
                iterador       = new Iterator <Vertex <T> >(ListaSucesores.GetCabeza());
            }

            return(ListaCaminoCorto);
        }
Ejemplo n.º 7
0
 public List <Place> GetRutaMinimaDijkstra(string pNombreVerticeA, string pNombreVerticeB)
 {
     try
     {
         ListD <Vertex <Place> > ListaCaminoMinimo = Graph.MiniDijkstraWay(pNombreVerticeA, pNombreVerticeB);
         if (ListaCaminoMinimo != null)
         {
             List <Place> ListaLugares           = new List <Place>();
             Iterator <Vertex <Place> > iterador = new Iterator <Vertex <Place> >(ListaCaminoMinimo.GetCabeza());
             for (Vertex <Place> verticeAdyac = iterador.Next(); verticeAdyac != null; verticeAdyac = iterador.Next())
             {
                 ListaLugares.Add(verticeAdyac.Info);
             }
             return(ListaLugares);
         }
     }
     catch (Exception e)
     {
         Console.WriteLine(e.Message);
     }
     return(null);
 }
Ejemplo n.º 8
0
 public bool EnlazarLista(ListD <T> lista)
 {
     return(Enlazar(this.GetCabeza(), lista));
 }
Ejemplo n.º 9
0
 public ListD <Vertex <T> > MiniDijkstraWay(string pNombreVerticeA, string pNombreVerticeB)
 {
     if (pNombreVerticeA != pNombreVerticeB && !IsGuide)
     {
         if (this.NegativeWeightatEdge())
         {
             throw new Exception("Existe algun valor negativo en el peso de los arcos");
         }
         HashTable <String, int> costosFinales    = GetHashTableByDijkstra();
         HashTable <String, int> costosTemporales = GetHashTableByDijkstra();
         string clave = null;
         this.CleanVerticeVisit();
         ListD <Vertex <T> > ListaAuxiliarDSucesores, ListaSucesores = this.GetListaSuccessors(pNombreVerticeA);
         Vertex <T>          verticeActual = this.GetVertexByName(pNombreVerticeA);
         verticeActual.IsVisit = true;
         Edge <T> arco = null;
         int      peso = 0, costo = 0;
         Iterator <Vertex <T> > iterador = new Iterator <Vertex <T> >(ListaSucesores.GetCabeza());
         bool noSalir = true;
         costosTemporales.ActualizarDatoPorClave(pNombreVerticeA, 0);
         costosFinales.ActualizarDatoPorClave(pNombreVerticeA, 0);
         while (noSalir)
         {
             for (Vertex <T> verticeAdyac = iterador.Next(); verticeAdyac != null; verticeAdyac = iterador.Next())
             {
                 arco = GetEdge(verticeActual.Name, verticeAdyac.Name);
                 if (arco != null)
                 {
                     costo = (int)arco.GetWeight() + peso;
                     if (costosTemporales.SearchByKey(arco.GetVertB().Name) > costo || costosTemporales.SearchByKey(arco.GetVertB().Name) == -1)
                     {
                         costosTemporales.ActualizarDatoPorClave(arco.GetVertB().Name, costo);
                     }
                 }
             }
             int index = -1, auxiliar = 0;
             clave = null;
             for (int i = 0; i < costosTemporales.GetSize(); i++)
             {
                 clave = costosTemporales.GetClave(i);
                 if ((auxiliar == 0 || auxiliar > costosTemporales.GetForIndex(i)) && (costosTemporales.GetForIndex(i) >= 0 && clave != null))
                 {
                     if (!VerticesGroup.SearchByKey(clave).IsVisit)
                     {
                         auxiliar = costosTemporales.GetForIndex(i);
                         index    = i;
                     }
                 }
             }
             if (index != -1)
             {
                 clave = costosTemporales.GetClave(index);
                 costosFinales.UpdateByIndex(index, auxiliar);
                 verticeActual         = VerticesGroup.SearchByKey(clave);
                 verticeActual.IsVisit = true;
             }
             else
             {
                 if (StopAnalisis())
                 {
                     noSalir = false;
                 }
             }
             ListaAuxiliarDSucesores = this.GetListSuccessorNotVisited(clave);
             if (ListaAuxiliarDSucesores.GetCabeza() != null)
             {
                 ListaSucesores = ListaAuxiliarDSucesores;
             }
             peso     = auxiliar;
             index    = -1;
             auxiliar = 0;
             iterador = new Iterator <Vertex <T> >(ListaSucesores.GetCabeza());
         }
         ListD <Vertex <T> > ListaCaminoCorto = GetCaminoMinimo(costosFinales, pNombreVerticeB);
         return(ListaCaminoCorto);
     }
     return(null);
 }