Esempio n. 1
0
        //metodos

        public void Borrar(Arista <Informacion> e)
        {
            Nodo <Arista <Informacion> > aux2 = conjunto.darSiguiente(); //auxiliar q apunta el siguiente nodo de aristas
            Nodo <Arista <Informacion> > aux  = conjunto;                //apunta al primer nodo de aristas

            if (conjunto.darDato().Equals(e))
            {
                conjunto = conjunto.darSiguiente();//si el primer nodo es igual al parametro e igualo el primer nodo con la direccion del siguiente para asi eliminarlo
            }

            else
            {
                while (aux2 != null)
                {
                    //si el siguiente nodo contien datos pasa al bucle
                    if (aux2.darDato().Equals(e))
                    {
                        aux.fijarSiguiente(aux2.darSiguiente());//si el nodo siguiente es igual al parametro coge el nodo anterior y hace que apunte al tercer nodo quitando asi el nodo igual al parametro
                    }


                    aux  = aux2;                //le doy a aux la direccion del siguiente nodo
                    aux2 = aux2.darSiguiente(); //le doy a al siguiente nodo la direccion de su siguiente
                }
            }
        }
Esempio n. 2
0
        public override bool Equals(Object obj)
        {
            bool confirmar           = false;
            Arista <Informacion> aux = obj as Arista <Informacion>;//variable de tipo arista guarda un null si el objeto recibido como parametro no es una arista en caso contrario guarda la arista q recibe como parametro

            if (aux != null)
            {
                confirmar = (aux.origen.Equals(this.origen) && aux.destino.Equals(this.destino) && aux.peso == this.peso);  //comparamos los parametros de la arista recibida origen destino y peso con los parametros de la arista actual
                //si son iguales confirmar adquiere el valor de true
            }
            return(confirmar);//devuelve el valor true o false q haya sido almacenado en la variable confirmar
        }
Esempio n. 3
0
        //metodo que no pide el ejercicio pero que creo para buscar aristas encontrarlas y guardarlas si las encuentra
        private Arista <Informacion> EncontrarArista(Informacion v1, Informacion v2, Arista <Informacion>[] arr)
        {
            Arista <Informacion> resultado = null;//guarda arista si la encuentra en el array de aristas obtenido del metodo

            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i].Destino.Equals(v2) && arr[i].Origen.Equals(v1))
                {
                    resultado = arr[i];
                }
            }

            return(resultado);
        }
Esempio n. 4
0
        public Arista <Informacion>[] obtenerAristas()
        {
            Nodo <Arista <Informacion> > aux2 = conjunto;                                 //auxiliar que apunta al primer nodo

            Arista <Informacion>[] array = new Arista <Informacion> [GetNumeroAristas()]; //array que va a guardar el conjutno de aristas o nodos
            int i = 0;                                                                    //contador para incrementar las posiciones del array

            while (aux2 != null)
            {
                array[i] = aux2.darDato();  //guardo el dato que contiene el nodo en el array
                i++;                        //incremento contador para incrementar posicion del array
                aux2 = aux2.darSiguiente(); //le doy la direccion del siguiente nodo al auxiliar para que compruebe si tiene informacion
            }

            return(array);//devuelvo el array
        }
Esempio n. 5
0
        public bool Pertence(Arista <Informacion> e)
        {
            Nodo <Arista <Informacion> > aux2 = conjunto; //auxiliar que apunta al primer nodo
            bool confirmar = false;                       //booleano para comprobar si el parametro e ya pertenece al conjunto de aristas

            while (aux2 != null)
            {
                if (aux2.darDato().Equals(e))
                {
                    confirmar = true;//si el dato que contiene el nodo es igual al parametro e cambia el valor del booleano a true
                    aux2      = null;
                }

                else
                {
                    aux2 = aux2.darSiguiente();//asigno nodo siguiente para comprobar
                }
            }

            return(confirmar);//devuelvo confirmar
        }
Esempio n. 6
0
        public void Insertar(Arista <Informacion> e)
        {
            if (!Pertence(e))
            {
                if (EsVacio())
                {
                    conjunto = new Nodo <Arista <Informacion> >(e);//si el parametro e no pertenece al nodo y si el nodo primero esta vacio inserto prametro e en el primer nodo
                }

                else
                {
                    Nodo <Arista <Informacion> > aux = conjunto;//si el primer nodo tiene datos me creo un auxiliar que apunta al primer nodo

                    while (aux.darSiguiente() != null)
                    {
                        aux = aux.darSiguiente();//si el nodo siguiente tiene datos asigno su siguiente para comprobar hasta que llegue al nodo sin informacion
                    }

                    aux.fijarSiguiente(new Nodo <Arista <Informacion> >(e));//cuando llego al nodo vacio inserto el parametro e en ese nodo
                }
            }
        }
Esempio n. 7
0
        public List <Informacion> CaminoMasCorto(Informacion origen, Informacion destino)
        {
            int numVertices = vertices.GetNumeroVertices();

            double[,] pesos = new double[numVertices, numVertices];
            int[,] caminos  = new int[numVertices, numVertices];
            Arista <Informacion>[] arrayAris  = aristas.obtenerAristas();
            Informacion[]          arrayVerti = vertices.ObtenerVertices();
            Arista <Informacion>   auxArista  = null;

            //algoritmo de floyd-Warshall
            //inicializamos la matriz de caminos y pesos

            for (int i = 0; i < numVertices; i++)
            {
                for (int j = 0; j < numVertices; j++)
                {
                    if (i == j)
                    {
                        caminos[i, j] = -1;
                        pesos[i, j]   = 0;
                    }
                    else
                    {
                        auxArista = EncontrarArista(arrayVerti[i], arrayVerti[j], arrayAris);
                        if (auxArista != null) //Si encuentro camino
                        {
                            pesos[i, j]   = auxArista.Peso;
                            caminos[i, j] = i;
                        }
                        else
                        {
                            pesos[i, j]   = Double.PositiveInfinity;
                            caminos[i, j] = -2;
                        }
                    }
                }
            }
            //algoritmo Floyd-Warshall
            double aux;

            for (int k = 0; k < numVertices; k++)
            {
                for (int i = 0; i < numVertices; i++)
                {
                    for (int j = 0; j < numVertices; j++)
                    {
                        aux = pesos[i, k] + pesos[k, j];

                        if (aux < pesos[i, j])
                        {
                            pesos[i, j]   = aux;
                            caminos[i, j] = k;
                        }
                    }
                }
            }



            //meto los datos del camino mas corto en una lista

            List <Informacion> lista = new List <Informacion>();
            int indiceOrigen         = -1;
            int indiceDestino        = -1;

            for (int i = 0; i < arrayVerti.Length; i++)
            {
                if (arrayVerti[i].Equals(destino))
                {
                    indiceDestino = i;
                }
                if (arrayVerti[i].Equals(origen))
                {
                    indiceOrigen = i;
                }
            }

            if (indiceOrigen == -1 || indiceDestino == -1)//si no hay camino devuelvo lista vacia
            {
                return(lista);
            }


            lista.Add(arrayVerti[indiceOrigen]);
            bool encontrado = false;
            int  siguiente  = indiceOrigen;
            int  anterior   = 0;

            while (!encontrado)
            {
                if (caminos[siguiente, indiceDestino] == siguiente)
                {
                    encontrado = true;
                    lista.Add(arrayVerti[indiceDestino]);
                }
                else if (caminos[siguiente, indiceDestino] == -2)
                {
                    encontrado = true;
                    lista.Clear(); //vaciar la lista
                }
                else if (caminos[siguiente, indiceDestino] == -1)
                {
                    encontrado = true;
                }
                else
                {
                    anterior  = siguiente;
                    siguiente = caminos[siguiente, indiceDestino];
                    if (caminos[anterior, siguiente] != anterior)
                    {
                        lista.Add(arrayVerti[caminos[anterior, siguiente]]);
                    }
                    lista.Add(arrayVerti[siguiente]);
                }
            }



            return(lista);
        }
Esempio n. 8
0
        public void BorrarArista(Informacion v1, Informacion v2, double peso)
        {
            Arista <Informacion> aux = new Arista <Informacion>(v1, v2, peso);//igual que la anterior funcion solo que esta tambien puede recibir y borrar el peso

            aristas.Borrar(aux);
        }
Esempio n. 9
0
        //metodos

        public void BorrarArista(Informacion v1, Informacion v2)
        {
            Arista <Informacion> aux = new Arista <Informacion>(v1, v2); //guardo en un auxiliar los parametros recibidos

            aristas.Borrar(aux);                                         //llamo al metodo borrar de aristas y le paso la variable aux q contiene los parametros que hay que borrar
        }