// INSERTAR UN VERTICE //////////// public String agregar_vertice(String nom) { Vertice verificar = getCab(); if (getCab() != null) { while (verificar !

= null) { if (verificar.getNombre().equals(nom)) { return "Un vertice ya posee este nombre / No existen vertice s"; } verificar = verificar.getSgte(); } } Vertice q = new Vertice(nom); if (getCab() == null) { setCab(q); setFin(q); } else { //Ubicarse en el ultimo nodo getFin().setSgte(q); setFin(q); } return "Vertice insertado existosamente"; } //////////////////////////////////////////////////////////// // AGREGAR UN ADYACENTE////////////////////////////////// public boolean agregar_adyacente(String ver_ini, String ver_final, int peso) { Vertice vi Vertice vf if ((vi == return } else { = buscar_vertice(ver_ini); = buscar_vertice(ver_final); null) || (vf == null)) { false;

vi.agregar_adya(vf, peso); //Actualizar el grado de entrada de vf y el grado de salida de vi vi.setGrado_sal(vi.getGrado_sal() + 1); vf.setGrado_ent(vf.getGrado_ent() + 1); return true;

} } // MODIFICAR UN VERTICE DEL GRAFO////////////////// public boolean actualizar_vertice(String nom_v, String n_v) { Vertice v = buscar_vertice(nom_v); if (v != null) { v.setNombre(n_v); } return (!(v == null)); } //////////////////////////////////////////////////////// // MODIFICAR UN ADYACENTE //////////////////////////// public int actualizar_adyacente(String vert_origen, String ady_mod, String n uevo_vert, int peso) {

Vertice v_o = buscar_vertice(vert_origen); if (v_o != null) { Adyacente a = buscar_ad(ady_mod); if (a != null) { Vertice V_insertar = buscar_vertice(nuevo_vert); if (V_insertar != null) { agregar_adyacente(vert_origen, nuevo_vert, peso); eliminar(vert_origen, ady_mod); return 0;// exito } else { return 1; // vertice final no existe } } else { return 2; //adyacente no existe } } else { return 3; //el vertice origen no existe }

} //////////////////////////////////////////////////////// // MOSTRAR LOS ADYACENTES DE UN VERTICE ///////////// public String mostrar_adyacente(String nom) { Vertice v = buscar_vertice(nom); String most = ""; if (v != null) { Adyacente a = v.getLista_ady(); if (a != null) { while (a != null) { most += v.getNombre() + "Ady " + a.getVer_final().getNombre() + "\n"; a = a.getSgte(); } } else { most = "El vertice no pose adyacentes"; } } else { most = "El vertice no ha sido localizado"; } return most; } //////////////////////////////////////////////////////// // MOSTRAR UN VERTICE DEL GRAFO ////////////////////// public String mostrar_vertice() { Vertice v = getCab(); String mostrar = ""; if (v != null) { while (v != null) { mostrar += "Vertice: " + v.getNombre() + "\nGrado entrada: " + v .getGrado_ent() + "\n Grado salida: " + v.getGrado_sal() + "\n"; v = v.getSgte(); }

} else { mostrar = "No existen vertices insertados\nGrafo vacio"; } return mostrar; } //////////////////////////////////////////////////////// // ELIMINAR UN VERTICE DEL GRAFO //////////////////////////////// public int eliminar_v(String nom) { Vertice v = getCab(); Vertice v_ant = null; boolean res = false; if (v != null) { while (v != null && res != true) { if (v.getNombre().equals(nom)) { res = true; } else { v_ant = v; v = v.getSgte(); } } if (res == true) { if (v.getGrado_ent() == 0 && v.getGrado_sal() == 0) { if (v == getCab()) { if (v.getSgte() == null) { setCab(null); setFin(null); } else { setCab(v.getSgte()); v.setSgte(null); } } else { v_ant.setSgte(v.getSgte()); v.setSgte(null); } return 0;// eliminado } else { return 1; } } else { return 2; } } else { return 2; } } //////////////////////////////////////////////////////// // BUSCAR UN VERTICE EN EL GRAFO ////////////////////////////// public Vertice buscar_vertice(String nom) { Vertice v = getCab(); if (v != null) { while (v != null) {

if (v.getNombre().equals(nom)) { return v; } else { v = v.getSgte(); } } } return null; } //////////////////////////////////////////////////////// // BUSCAR UN ADYACENTE////////////////////////////////// public Adyacente buscar_ad(String nom_a) { Adyacente a = getCab().getLista_ady(); if (a != null) { while (a != null) { if (a.getVer_final().getNombre().equals(nom_a)) { return a; } else { a = a.getSgte(); } } } return null; } //////////////////////////////////////////////////////// // ELIMINAR UN ADYACENTE ///////////////////////////////// public int eliminar(String v_origen, String v_fin) { Vertice v = buscar_vertice(v_origen); boolean res = false; if (v != null) { int g_salida = 0; int g_entrada = 0; Adyacente ady = v.getLista_ady(); Adyacente ant_ady = null; if (ady != null) { if (ady == v.getLista_ady() && ady.getVer_final().getNombre().eq uals(v_fin)) { if (ady.getSgte() == null) { v.setLista_ady(null); g_salida--; g_entrada--; } else { v.setLista_ady(ady.getSgte()); ady.setSgte(null); g_salida--; g_entrada--; }

} else { while (ady != null && res != true) { if (ady.getVer_final().getNombre().equals(v_fin)) {

res = true; } else { ant_ady = ady; ady = ady.getSgte(); } } if (res == true) { ant_ady.setSgte(ady.getSgte()); ady.setSgte(null); g_salida--; g_entrada--; } } v.setGrado_sal(v.getGrado_sal() + g_salida); Vertice bus = buscar_vertice(v_fin); bus.setGrado_ent(bus.getGrado_ent() + g_entrada); return 0; } else { return 1;// adyacente no encontrado } } else { return 2; } } public String recorrido_por_anchura() { Queue<Vertice> cola = new LinkedList<Vertice>(); ArrayList<Vertice> visitados = new ArrayList<Vertice>(); LinkedList<String> mos = new LinkedList<String>(); cola.add(cab); visitados.add(cab); while (!cola.isEmpty()) { Vertice v = cola.poll(); mos.add(v.getNombre()); Adyacente a = v.getLista_ady(); while (a != null) { if (!visitados.contains(a.getVer_final())) { cola.add(a.getVer_final()); visitados.add(a.getVer_final()); } a = a.getSgte(); } } return mos.toString(); } //PROFUNDIDAD CON RECURSIVIDAD////////////////////////////////// public void recursividad_para_profundidad(Vertice v, LinkedList<Vertice> ln, LinkedList<String> nom) {//recibimos cabeza Adyacente ad = v.getLista_ady(); if (ad != null) { while (ad != null) { if (!ln.contains(ad.getVer_final())) { ln.add(ad.getVer_final()); nom.add(ad.getVer_final().getNombre()); }

recursividad_para_profundidad(ad.getVer_final(), ln, nom); ad = ad.getSgte(); } } } public String Recorrido_por_Profundidad() { Vertice ptr = cab; LinkedList<String> msj = new LinkedList<String>(); LinkedList<Vertice> lis_v = new LinkedList<Vertice>(); if (ptr != null) { msj.add(cab.getNombre()); lis_v.add(cab); while (ptr != null) { recursividad_para_profundidad(ptr, lis_v, msj); ptr = ptr.getSgte(); } return (msj.toString()); } else { return ("Grafo Vacio"); } } //////////////////////////////////////////////////////// // PROFUNDIDAD CON PILA////////////////////////////////////////// public String recorrido_profundidad_pila() { Stack<Vertice> pila = new Stack<Vertice>(); ArrayList<Vertice> visitados = new ArrayList<Vertice>(); LinkedList<String> mos = new LinkedList<String>(); if (cab != null) { pila.add(cab); visitados.add(cab); while (!pila.isEmpty()) { Vertice v = pila.pop(); mos.add(v.getNombre()); Adyacente ad = v.getLista_ady(); while (ad != null) { if (!visitados.contains(ad.getVer_final())) { pila.add(ad.getVer_final()); visitados.add(ad.getVer_final()); } ad = ad.getSgte(); } } return mos.toString(); } else { return "Grafo vacio"; } } public LinkedList ady_visitados(Adyacente ady, LinkedList<Vertice> lis) {//m etodo recursivo. lis.add(ady.getVer_final()); // lis.insertar(ady.getVer_final()); ady = ady.getVer_final().getLista_ady(); while (ady != null) { if (lis.contains(ady.getVer_final()) == false) {

ady_visitados(ady, lis); } ady = ady.getSgte(); } return lis; } ///////////////////////////////////////// // RECORRIDO TOPOLOGICO DE UN GRAFO////////////////// public String Recorrido_Topologico() { Queue<Vertice> cola = new LinkedList(); LinkedList<Adyacente> lista = new LinkedList(); Vertice q = cab; LinkedList<String> recorrido = new LinkedList<String>(); while (q != null) { Adyacente nuevo_vertice = new Adyacente(q, q.getGrado_ent()); lista.add(nuevo_vertice); if (q.getGrado_ent() == 0) { cola.add(q); } q = q.getSgte(); } while (!cola.isEmpty()) { Vertice ver = cola.poll(); Adyacente adya = ver.getLista_ady(); while (adya != null) { Adyacente bus = null; for (int i = 0; i < lista.size(); i++) { bus = lista.get(i); if (bus.getVer_final() == adya.getVer_final()) { break; } } bus.setPeso(bus.getPeso() - 1); if (bus.getPeso() == 0) { cola.add(bus.getVer_final()); } adya = adya.getSgte(); } recorrido.add(ver.getNombre()); } return recorrido.toString(); } public String mostrar_Cola(Queue<Nodo_Camino> cola) { String ms = ""; while (!cola.isEmpty()) { Nodo_Camino ver = cola.poll(); ms += ver.getVert().getNombre() + " " + ver.getAd().getPeso() + "\n" ; } return ms; } //////////////////////////////////////////////

// KRUSKAL////////////////////////////////////// public Grafo recorridoKrusKal(Grafo gp) { Grafo Grafo_Nuevo = new Grafo(); // Grafo Nuevo Vertice v = gp.getCab(); while (v != null) {// rellenamos el nuevo grafo con los vertices del gra fo dado pero sin formar caminos. Grafo_Nuevo.agregar_vertice(v.getNombre()); v = v.getSgte(); } Vector<Nodo_Camino> vector = vector_vertices_ordenados(gp);// VECTOR CON LOS VERTICES DEL GRAFO DADO Queue<Nodo_Camino> cola = Insertarcola(vector);// COLA ORDENADA DE LOS C AMINOS QUE POSEE EL GRAFO DADO while (!cola.isEmpty()) { Nodo_Camino obj = cola.poll();// OBTENEMOS EL PRIMER OBJETO DE LA CO LA EL CUAL SERA ORDENADO String vertice1 = obj.getVert().getNombre();// OBTENEMOS EL VERTICE String vertice2 = obj.getAd().getVer_final().getNombre(); if (Grafo_Nuevo.probar_ciclo(vertice1, vertice2) == false) { if (Grafo_Nuevo.probar_ciclo(vertice2, vertice1) == false) { Grafo_Nuevo.agregar_adyacente(vertice1, vertice2, obj.getAd( ).getPeso()); } } } return Grafo_Nuevo; } public boolean probar_ciclo(String m1, String m2) { Queue<Vertice> cola = new LinkedList<Vertice>(); ArrayList<Vertice> visitados = new ArrayList<Vertice>(); Vertice v1 = buscar_vertice(m1); Vertice v2 = buscar_vertice(m2); cola.add(v1); visitados.add(v1); Adyacente ad = v1.getLista_ady(); if (ad != null) { while (ad != null) { if (ad.getVer_final() == v2) { return false; } cola.add(v1); visitados.add(v1); ad = ad.getSgte(); } } while (!cola.isEmpty()) { Vertice v = cola.poll(); if (v == v2) { return true; } Adyacente a = v.getLista_ady(); while (a != null) { if (!visitados.contains(a.getVer_final())) { cola.add(a.getVer_final());

visitados.add(a.getVer_final()); } a = a.getSgte(); } } return false; } public Queue<Nodo_Camino> Insertarcola(Vector<Nodo_Camino> vec) { Queue<Nodo_Camino> cola = new LinkedList<Nodo_Camino>(); for (int i = 0; i < vec.size(); i++) { cola.add(vec.get(i)); } return cola; } public Vector<Nodo_Camino> vector_vertices_ordenados(Grafo g) { Vertice ver = g.getCab(); Vector<Nodo_Camino> vector = new Vector<Nodo_Camino>(); if (ver != null) { while (ver != null) { Adyacente ad = ver.getLista_ady(); if (ad != null) { while (ad != null) { Nodo_Camino n_k = new Nodo_Camino(ver, ad); vector.add(n_k); ad = ad.getSgte(); } } ver = ver.getSgte(); } } bubbleSort(vector); return vector; } public static void bubbleSort(Vector<Nodo_Camino> x) { boolean doMore = true; while (doMore) { doMore = false; // assume this is last pass over array for (int i = 0; i < x.size() - 1; i++) { if (x.get(i).getAd().getPeso() > x.get(i + 1).getAd().getPeso()) { // exchange elements Nodo_Camino temp = x.get(i); x.set(i, x.get(i + 1)); x.set(i + 1, temp); doMore = true; // after an exchange, must look again } } } } /////////////////////////////////////////////////////////////////// //ALGORITMO DE PRIM. (ALGORITMO DE EXPANSION PARCIALMENTE MINIMA DE UN ARBO

L) // metodo para ordenar la cola de caminos public void cola_ordenada(Queue<Nodo_Camino> col) {// recibimos la cola Vector<Nodo_Camino> vector = new Vector<Nodo_Camino>();// creamos un vec tor donde almacenaremos los caminos que tiene la cola while (!col.isEmpty()) { Nodo_Camino nod_k = col.poll(); vector.add(nod_k); }

bubbleSort(vector);// ordenamos los elementos que tiene el vector de cam inos for (int i = 0; i < vector.size(); i++) { col.add(vector.get(i));// volvemos a insertar los elementos pero est os ya ordenados de menor a mayor } } public Grafo Prim(Grafo antiguo_grafo, String nombre) { Grafo nuevo_grafo = new Grafo();// creamos el grafo que devolvera el alg oritmo Queue<Nodo_Camino> cola = new LinkedList<Nodo_Camino>();// creamos la co la de caminos LinkedList<Vertice> visitados = new LinkedList<Vertice>();// lista de vi sitados Vertice vert = antiguo_grafo.buscar_vertice(nombre);// buscamos en verti ce del cual vamos a partir Vertice v_antiguo_grafo = antiguo_grafo.getCab();// obtenemos la cabeza del grafo antiguo while (v_antiguo_grafo != null) {// insertamos todos los vertices del an tiguo grafo nuevo_grafo.agregar_vertice(v_antiguo_grafo.getNombre()); v_antiguo_grafo = v_antiguo_grafo.getSgte(); } visitados.add(vert); Adyacente ad = vert.getLista_ady();// obtenemos el adyacente del ver tice que en este caso es el de menor recorrido al cual podemos dirigirnos while (ad != null) {// extraemos los caminos de ese vertice tomando sus adyacentes Nodo_Camino nodo_k = new Nodo_Camino(vert, ad);// creamos el nod o camino cola.add(nodo_k);// lo insertamos en la cola ad = ad.getSgte(); } while (!cola.isEmpty()) { // mientras la cola no este vacia cola_ordenada(cola);// ordenamos la cola de menor a mayor dependiend o de la arista Nodo_Camino nodo_extraido = cola.poll();// extraemos el que es el me nor camino al cual podemos dirigirnos Vertice v = nodo_extraido.getAd().getVer_final(); if (!visitados.contains(v)) { visitados.add(v); if (probar_ciclo(nodo_extraido.getVert().getNombre(), nodo_extra ido.getAd().getVer_final().getNombre()) == false) {// verificamos si existe cicl

o entre esos vertices por ambos lados if (probar_ciclo(nodo_extraido.getAd().getVer_final().getNom bre(), nodo_extraido.getVert().getNombre()) == false) { nuevo_grafo.agregar_adyacente(nodo_extraido.getVert( ).getNombre(), nodo_extraido.getAd().getVer_final().getNombre(), nodo_extraido.g etAd().getPeso());// si no existe ciclo insertamos este camino a nuestro nuevo g rafo // obtenemos el vertice del adyacente para localizar nuevos caminos accesibles if (v.getLista_ady() != null) { Adyacente ady = v.getLista_ady(); while (ady != null) { Nodo_Camino nodo = new Nodo_Camino(v, ady); cola.add(nodo); ady = ady.getSgte(); } } } } } } return nuevo_grafo; } public void mostrarcolita(Queue<Nodo_Camino> cola) { String most = ""; while (!cola.isEmpty()) { Nodo_Camino nod = cola.poll(); most += nod.getAd().getPeso() + " "; } JOptionPane.showMessageDialog(null, most); } //////////////////////////////////////////////////////// // CAMINOS MAS CORTO DE UN VERTICE///////////////////////////////// public String Djstra(String nombre, boolean incluirPeso) { Vertice ver = buscar_vertice(nombre);// buscamos el inicio del recorrido Lista_Etiquetas lista_etiquetas = new Lista_Etiquetas(); LinkedList<Vertice> Visitados = new LinkedList<Vertice>(); // lista donde estaran las etiquetas del recorrido // lista de vertices visitados Nodo_Etiqueta primera = new Nodo_Etiqueta(0, null, ver, ver.getNombre()) ; lista_etiquetas.insertar(primera); int num_revisados = 0; int num_eliminados = 0; do { Nodo_Etiqueta menor = etiqueta_menor_recorrido(lista_etiquetas); menor.setSw(true); Visitados.add(menor.getActual()); num_revisados++;

Vertice vert = menor.getActual(); Adyacente ad = vert.getLista_ady(); while (ad != null) { if (!Visitados.contains(ad.getVer_final())) { Nodo_Etiqueta nueva_etiqueta = new Nodo_Etiqueta(menor.getRe corrido() + ((incluirPeso) ? ad.getPeso() : 1), menor.getOrigen(), ad.getVer_fin al(), menor.getCad_rec() + " " + ad.getVer_final().getNombre()); num_eliminados = lista_etiquetas.insertar(nueva_etiqueta); Visitados.add(ad.getVer_final()); } num_revisados += num_eliminados; ad = ad.getSgte(); } } while (num_revisados < lista_etiquetas.getDimension());

return lista_etiquetas.toString(); } public Nodo_Etiqueta etiqueta_menor_recorrido(Lista_Etiquetas ne) {// buscam os en la lista de etiquetas la de menor recorrido. Nodo_Etiqueta ret = null; Nodo_Etiqueta n; if (ne.getCab() != null) { int rec = 0; n = ne.getCab(); while (n != null) { if (!n.isSw()) { if (ret == null) { ret = n; rec = n.getRecorrido(); } else if (rec > n.getRecorrido()) { rec = n.getRecorrido(); ret = n; } } n = n.getSig(); } } if (ret == null) { int b = 0; } return ret; } /////////////////////////////////////////////////////////// //ALGORITMO DE FLOYD public String floyd(boolean tipo) { String msg = ""; Vertice v = cab; if (v == null) { msg = "GRAFO VACIO NO SE PUEDE REALIZAR EL ALGORITMO\n\n";

} else { while (v != null) { msg += "Recorrido del vertice

" + v.getNombre() + "\n\n";

if (v.getGrado_sal() == 0 && v.getGrado_ent() == 0) { msg += "Vertice: " + v.getNombre() + " No Posee salidas Ni No Posee salidas"; } else if (v.getGrado_sal() == 0) { msg += "Vertice: " + v.getNombre() + " No Posee salidas"; } else { String dj = Djstra(v.getNombre(), ((tipo) ? true : false)); msg += ((dj.equals("") ? "" : dj)); } msg += "\n\n==================================================== ====================\n\n"; v = v.getSgte(); } } return msg; }