//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
}
}
}
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
}
//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);
}
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
}
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
}
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
}
}
}
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);
}
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);
}
//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
}
