Unidad Profesional Interdisciplinaria

en Ingeniería y Tecnologías
Avanzadas

Alumnos:
Sánchez López José Uriel
Santana Islas Gerardo Leonardo
Terres Reyes Ana Laura
Valaguez Manjarrez Enrique

Unidad de Aprendizaje:
Estructura de Datos

Profesor
Juan Carlos Razo Ruiz

Proyecto final

Periodo
2020-2
 Índice
Introducción ------------------------------------------------------------------ 3

Código ------------------------------------------------------------------------- 3

• Clase arista ---------------------------------------------------------- 3

• Clase circulo --------------------------------------------------------- 6
• Clase coordenadas ----------------------------------------------- 10
• Clase enlace -------------------------------------------------------- 12
• Clase grafo ---------------------------------------------------------- 13
• Clase Línea quebrada -------------------------------------------- 21
• Clase Nodo ---------------------------------------------------------- 26
• Clase Disjktra ------------------------------------------------------- 30
• Clase Lista Nodo --------------------------------------------------- 34

Código de la Interfaz ------------------------------------------------------- 36

• Clase GUI ------------------------------------------------------------ 35

• Clase historial ------------------------------------------------------- 64

Manual de uso --------------------------------------------------------------- 67

Conclusiones ----------------------------------------------------------------- 80

Bibliografía -------------------------------------------------------------------- 82

2
 INTRODUCCION

Los algoritmos de búsqueda han sido una de las más grandes herramientas
en cuestión de consultas y organización de datos, lo que nos permite encontrar
la información de manera concisa y rápida.

En este proyecto se mostrará el funcionamiento de manera más concisa del

algoritmo de Dijkstra, explorando los diferentes caminos para obtener el mejor
resultado en el camino más optimizado para satisfacer las problemáticas
donde se necesita el camino más corto.

CODIGO

Clase Arista

package objetos;

public class Arista {

//declaración de las variables
private int idArista;
private String nombreArista;
//Distancia entre dos puntos
private int distancia;
private LineaQuebrada lineaQuebrada;
private boolean habilitado;
//Declaracion de los constructores
public Arista(){
// Inicializando variables de instancia
this(-1,"");

3
}
public Arista(int idArista){
// Inicializando variables de instancia
this(-1,"");
}
public Arista(int idArista,String nombreArista){
// Inicializando variables de instancia
this(-1,"",1);
}
public Arista(int idArista,String nombreArista,int peso){
// Inicializando variables de instancia

this.idArista = idArista;
this.nombreArista = nombreArista;
this.distancia = peso;
lineaQuebrada = null;
habilitado = true;
}
//Declaracion de los setters y getters de las variables

public void setIdArista(int idArista){

this.idArista = idArista;
}
public int getIdArista(){
return idArista;
}
public void setNombreArista(String nombreVia){
this.nombreArista = nombreVia;

4
}
public String getNombreArista(){
return nombreArista;
}
public void setPeso(int peso){
this.distancia = peso;
}
public int getPeso(){
return distancia;
}
public void setLineaQuebrada(LineaQuebrada lineaQuebrada){
this.lineaQuebrada = lineaQuebrada;
if(lineaQuebrada != null){
this.lineaQuebrada.setLongitud(distancia);
}
}
public LineaQuebrada getLineaQuebrada(){
return lineaQuebrada;
}

public boolean isHabilitado() {

return habilitado;
}

public void setHabilitado(boolean habilitado) {

this.habilitado = habilitado;
}

5
 }

Clase Circulo

package objetos;
import java.awt.*;

public class Circulo

{
// Declaración de las variables

private Coordenadas coordenadas;

private Color color;
private int diametro;
private String etiqueta;
private Font fuente;
private int izquierda;
private int grosorBorde;
// Declaración de los constructores

public Circulo(Coordenadas coordenadas){

//inicializando las variables

this.coordenadas = coordenadas;
color = Color.yellow;
diametro = 10;
etiqueta = "";
fuente = null;
izquierda = 0;

6
 grosorBorde = 2;
}
//Clase de la creación del circulo

public void dibujarCirculo(Graphics g){

if(coordenadas.size() > 0){
((Graphics2D)g).setColor(color);
((Graphics2D)g).setStroke(new BasicStroke(getGrosorBorde()));

((Graphics2D)g).fillOval(coordenadas.get(0)[0],coordenadas.get(0)[1],diam
etro,diametro);
((Graphics2D)g).setColor(Color.black);

((Graphics2D)g).drawOval(coordenadas.get(0)[0],coordenadas.get(0)[1],dia
metro,diametro);
if(!"".equals(etiqueta)){
if(fuente != null){
g.setFont(fuente);
}
((Graphics2D)g).drawString(etiqueta,coordenadas.get(0)[0] -
(izquierda),coordenadas.get(0)[1]);
((Graphics2D)g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
}
}else{
System.out.println("No hay coordenadas para el circulo");
}
}

7
//Declaración de los setters y getters de las variables

public void setColor(Color color){

this.color = color;
}
public Color getColor(){
return color;
}
public void setDiametro(int diametro){
this.diametro = diametro;
}
public int getDiametro(){
return diametro;
}
public void setEtiqueta(String etiqueta){
this.etiqueta= etiqueta;
}
public void setEtiqueta(String etiqueta,boolean izquierda){
this.etiqueta= etiqueta;
}
public String getEtiqueta(){
return etiqueta;
}
public int getX(){
if(coordenadas.size() > 0){
return coordenadas.get(0)[0];
}else{

8
 return -1;
}
}
public int getY(){
if(coordenadas.size() > 0){
return coordenadas.get(0)[1];
}else{
return -1;
}
}
public Font getFuente() {
return fuente;
}
public void setFuente(Font fuente) {
this.fuente = fuente;
}
public int isIzquierda() {
return izquierda;
}
public void setIzquierda(int izquierda) {
this.izquierda = izquierda;
}
public int getGrosorBorde() {
return grosorBorde;
}
public void setGrosorBorde(int grosorBorde) {
this.grosorBorde = grosorBorde;

9
 }
}

Clase coordenadas

package objetos;
import java.util.ArrayList;

public class Coordenadas extends ArrayList < int[] >

{
// Declaración de las variables

private int xMaxima;

private int yMaxima;
// Declaración de los constructores

public Coordenadas(){
// inicializando variables de instancia

this(0, 0);
}
public Coordenadas(int xMaxima, int yMaxima){
// inicializando variables de instancia

super();
this.xMaxima = xMaxima;
this.yMaxima = yMaxima;
}
public Coordenadas(int xMaxima, int yMaxima,int x, int y){
// inicializando variables de instancia

10
 super();
this.xMaxima = xMaxima;
this.yMaxima = yMaxima;
addCoordenada(x,y);
}
//Declaración de los setters y getters de las variables

public void setXMaxima(int xMaxima){

this.xMaxima = xMaxima;
}
public void setYMaxima(int yMaxima){
this.yMaxima = yMaxima;
}

public void addCoordenada(int x, int y){

if(x >= 0 && x <= xMaxima && y >= 0 && y <= yMaxima)
{
int[] parXY = {x, y};
add(parXY);
}
}
public int getxMaxima() {
return xMaxima;
}
public int getyMaxima() {
return yMaxima;
}

11
}

Clase enlace

package objetos;

public class Enlace{

//Declaración de variables

private Arista arista;

private Nodo nodo;
//Constructor para objetos de la clase Arista

public Enlace(){
// inicializando variables

this(new Arista(),new Nodo());

}
public Enlace(Arista arista,Nodo nodo){
// inicializando variables

this.arista = arista;
this.nodo = nodo;
}
//Declaración de setters y getters

public void setArista(Arista arista){

this.arista = arista;
}
public Arista getArista(){
return arista;

12
 }
public void setNodo(Nodo nodo){
this.nodo = nodo;
}
public Nodo getNodo(){
return nodo;
}
}

Clase grafo

package objetos;
//importación de librerias

import java.awt.Color;
import java.util.ArrayList;

public class Grafo{

//Declaración de un array

private ArrayList<Nodo> listaNodo;

//Declaración del constructor

public Grafo(){
//Inciando el arreglo
listaNodo = new ArrayList<Nodo>();
}

13
 //Metodo de adjuntacion de nodos en el recorrido

public boolean adjuntarNodo(Nodo nodo){

Nodo nodoTemp = buscarNodo(nodo.getDato());
if(nodoTemp == null){
listaNodo.add(nodo);
return true;
}else{
return false;
}
}
//Metodo de creación de enlaces para el recorrido del grafo

public void crearEnlacesDirigido(Nodo padre,Nodo adyacente,Arista

arista){
if(padre != null && adyacente != null){
padre.addNodoAdyacente(arista,adyacente);
}
}
//Metodo de crear enlaces

public void crearEnlacesNoDirigido(Nodo padre,Nodo adyacente,Arista

arista){
crearEnlacesDirigido(padre, adyacente, arista);
crearEnlacesDirigido(adyacente,padre, arista);
}
//Metodo de búsqueda en nodos

public Nodo buscarNodo(Object dato){

Nodo temp = null;

14
 if(dato != null){
for(Nodo nodo:listaNodo){
if(dato.equals(nodo.getDato())){
temp = nodo;
}
}
}
return temp;
}
//Metodo de búsqueda en nodos con coordenadas

public Nodo buscarNodo(int x, int y){

Nodo nodoAuxiliar = null;
for(int i = 0; i < listaNodo.size(); i++){
int xNodo = listaNodo.get(i).getCirculo().getX();
int yNodo = listaNodo.get(i).getCirculo().getY();
if(x > xNodo && x < (xNodo +
listaNodo.get(i).getCirculo().getDiametro())){
if(y > yNodo && y < (yNodo +
listaNodo.get(i).getCirculo().getDiametro())){
nodoAuxiliar = listaNodo.get(i);
break;
}
}
}
return nodoAuxiliar;
}

15
//Declaracion de setters y getters

public ArrayList<Nodo> getAdyacentes(Object dato){

ArrayList<Nodo> lista = null;
Nodo principal = buscarNodo(dato);
ArrayList<Enlace> aristas = principal.getListaNodoAdyacente();
if(aristas != null){
for(int i = 0; i < aristas.size();i++){
lista.add(aristas.get(i).getNodo());
}
}
return lista;
}
public ArrayList<Nodo> getListaNodos(){
return listaNodo;
}
public boolean isAdyacente(Nodo n1,Nodo n2){
boolean aux = false;
ArrayList<Enlace> listaAristas = n1.getListaNodoAdyacente();
if(listaAristas != null){
for(int i = 0;i < listaAristas.size();i++){
if(listaAristas.get(i).getNodo() == n2){
aux = true;
}
}
}
return aux;

16
 }
public boolean isAdyacente(Object datoNodoInicio,Object
datoNodoDestino){
boolean aux = false;
Nodo n1 = buscarNodo(datoNodoInicio);
Nodo n2 = buscarNodo(datoNodoDestino);
ArrayList<Enlace> listaAristas = n1.getListaNodoAdyacente();
if(listaAristas != null){
for(int i = 0;i < listaAristas.size();i++){
if(listaAristas.get(i).getNodo() == n2){
aux = true;
}
}
}
return aux;
}
public Arista getArista(Object datoNodo1,Object datoNodo2){
return getArista(buscarNodo(datoNodo1),buscarNodo(datoNodo2));
}
public Arista getArista(String nombreVia){
Arista aux = null;
if(nombreVia != null){
ArrayList<Nodo> listaN = listaNodo;
for(Nodo nd:listaN){
ArrayList<Enlace> lA = nd.getListaNodoAdyacente();
for(Enlace enlace:lA){
if(enlace.getArista().getNombreArista().equals(nombreVia)){

17
 aux = enlace.getArista();
}
}
}
}
return aux;
}
public Arista getArista(Nodo n1,Nodo n2){
Arista aux = null;
if(isAdyacente(n1, n2)){
ArrayList<Enlace> listaAristas = n1.getListaNodoAdyacente();
for(int i = 0;i < listaAristas.size();i++){
if(listaAristas.get(i).getNodo() == n2){
aux = listaAristas.get(i).getArista();
}
}
}else if(isAdyacente(n2, n1)){
aux = getArista(n2, n1);
}
return aux;
}
public Enlace getEnlace(Object datoNodo1,Object datoNodo2){
Enlace aux = null;
if(isAdyacente(datoNodo1, datoNodo2)){
Nodo n1 = buscarNodo(datoNodo1);
Nodo n2 = buscarNodo(datoNodo2);
ArrayList<Enlace> listaAristas = n1.getListaNodoAdyacente();

18
 for(int i = 0;i < listaAristas.size();i++){
if(listaAristas.get(i).getNodo() == n2){
aux = listaAristas.get(i);
}
}
}
else if(isAdyacente(datoNodo2, datoNodo1)){
aux = getEnlace(datoNodo2, datoNodo1);
}
return aux;
}
//Metodo de reinicio del grafo para el funcionamiento del algoritmo disjktra

public void reiniciarGrafoParaDisjktra(){

for(Nodo n:listaNodo){
n.setMarca(false);
n.setNodoAntecesorDisjktra(null);
n.setLongitudCamino(-1);
}
}
//Metodo de eliminación de nodos

public boolean eliminarNodo(Nodo nodo){

boolean retornado = false;
if(nodo !=null){
retornado = listaNodo.remove(nodo);
}
return retornado;

19
 }
//Metodo de reinicio de colores del grafo

public void reiniciarColores() {

if(listaNodo != null){
for(Nodo nodo: listaNodo){
nodo.getCirculo().setColor(Color.yellow);
ArrayList<Enlace> la = nodo.getListaNodoAdyacente();
if(la != null){
for(Enlace enlace:la){
if(enlace.getArista().isHabilitado()){

enlace.getArista().getLineaQuebrada().setColor(Color.black);
enlace.getArista().getLineaQuebrada().setGrosorLinea(1);
}
}
}
}
}
}
//Metodo de creación de aristas con arreglos

public ArrayList<Arista> aristas(Nodo nodo) {

ArrayList<Arista> listaArista = null;
ArrayList<Enlace> enlaces = nodo.getListaNodoAdyacente();
if (enlaces != null) {
listaArista = new ArrayList<Arista>();
for (Enlace e : enlaces) {

20
 listaArista.add(e.getArista());
}
}
return listaArista;
}
//Metodo de eliminación de aristas

public void eliminarAristas(Nodo nodo) {

ArrayList<Arista> aristas = aristas(nodo);
if (aristas != null) {
for (int i = 1; i <= aristas.size(); i++) {
aristas.get(i - 1).setHabilitado(false);
}
}
}
}

Clase Línea quebrada

package objetos;
import java.awt.*;

public class LineaQuebrada

{
//Declaración de variables
private Coordenadas coordenadas;
private Color color;
private float grosorLinea;

21
 private String etiqueta;
private int longitud;
private boolean mostrarEtiqueta;
//Declaracion de constructores
public LineaQuebrada(Coordenadas coordenadas){
// inicializando variables
this.coordenadas = coordenadas;
grosorLinea = 1f;
color = Color.black;
mostrarEtiqueta = false;
}
//Metodo para dibujar la línea para mostrar la trayectoria
public void dibujarLineaQuebrada(Graphics g){
((Graphics2D)g).setColor(getColor());

((Graphics2D)g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
BasicStroke stroke = new BasicStroke(grosorLinea);
((Graphics2D)g).setStroke(stroke);
if(coordenadas != null){
int []aux = new int[0];
for(int i = 0; i < coordenadas.size(); i++){
aux = coordenadas.get(i);
if(i == 0){
((Graphics2D)g).drawLine(aux[0],aux[1],aux[0],aux[1]);
}else{

22
 ((Graphics2D)g).drawLine(coordenadas.get(i -
1)[0],coordenadas.get(i - 1)[1],aux[0],aux[1]);
}
}

if(mostrarEtiqueta){
((Graphics2D)g).setColor(Color.blue);
Font fuente=new Font("Monospaced",Font.BOLD, 12);
g.setFont(fuente);

if(coordenadas.size() == 2){
int xMenor =
menor(coordenadas.get(0)[0],coordenadas.get(1)[0]);
int yMenor =
menor(coordenadas.get(0)[1],coordenadas.get(1)[1]);

int xMayor =
mayor(coordenadas.get(0)[0],coordenadas.get(1)[0]);
int yMayor =
mayor(coordenadas.get(0)[1],coordenadas.get(1)[1]);

int distanciaVertical = yMayor - yMenor;

int distanciaHorizontal = xMayor - xMenor;
((Graphics2D)g).drawString(longitud+"",(distanciaHorizontal/2)
+ xMenor,(distanciaVertical/2) + yMenor);
}else{
int pos = coordenadas.size() / 2;

23
((Graphics2D)g).drawString(longitud+"",coordenadas.get(pos)[0]+3,coorden
adas.get(pos)[1]-8);

}
}
}

stroke = new BasicStroke(1);

((Graphics2D)g).setStroke(stroke);

}
//Metodo para obtener los mayor y menor
private int mayor(int n1,int n2){
return (n1 > n2) ? n1 : n2;
}
private int menor(int n1,int n2){
return (n1 < n2) ? n1 : n2;
}
//Declaración de setters y getters
public void setColor(Color color){
this.color = color;
}
public Color getColor(){
return color;
}

24
public void setGrosorLinea(float grosorLinea){
this.grosorLinea = grosorLinea;
}
public float getGrosorLinea(){
return grosorLinea;
}
public void setEtiqueta(String etiqueta){
this.etiqueta= etiqueta;
}
public String getEtiqueta(){
return etiqueta;
}

public int getLongitud() {

return longitud;
}

public void setLongitud(int longitud) {

this.longitud = longitud;
}

public Coordenadas getCoordenadas() {

return coordenadas;
}

public void setCoordenadas(Coordenadas coordenadas) {

this.coordenadas = coordenadas;

25
 }

public boolean isMostrarEtiqueta() {

return mostrarEtiqueta;
}

public void setMostrarEtiqueta(boolean mostrarEtiqueta) {

this.mostrarEtiqueta = mostrarEtiqueta;
}
}

Clase Nodo

package objetos;
import java.util.ArrayList;

public class Nodo{

//Declaración de variables

private Object dato;

private ArrayList<Enlace> listaNodoAdyacente;
private boolean visitado = false;
private Circulo circulo;
private int izquierda;
//Para uso de la clase Disjktra

private int longitudCamino;

private Nodo nodoAntecesorDisjktra;
private boolean marca;

26
//Declaración de constructores

public Nodo(){
this.dato = new Object();
circulo = null;
izquierda = 0;
inicializarParaDisjktra();
}
//Metodo para iniciar el algoritmo disjktra

private void inicializarParaDisjktra(){

longitudCamino = -1;
nodoAntecesorDisjktra = null;
marca = false;
}
//Declaración de constructor

public Nodo(Object dato,Coordenadas coordenada){

this.dato = dato;
listaNodoAdyacente = new ArrayList<Enlace>();
circulo = new Circulo(coordenada);
circulo.setIzquierda(izquierda);
inicializarParaDisjktra();
}
//Declaración de setters y getters

public void setDato(Object dato){

this.dato = dato;
}
public Object getDato(){

27
 return this.dato;
}
public ArrayList<Enlace> getListaNodoAdyacente(){
ArrayList<Enlace> listAristaAux = null;
if(!listaNodoAdyacente.isEmpty()){
listAristaAux = new ArrayList<Enlace>();
for(Enlace enlace:listaNodoAdyacente){
if(enlace.getArista().isHabilitado()){
listAristaAux.add(enlace);
}
}
}
return listAristaAux;
}

Public void setListaNodoAdyacente(ArrayList<Enlace>

listaNodoAdyacente) {
this.listaNodoAdyacente = listaNodoAdyacente;
}
//Metodos de agregación de agregación de nodos

public void addNodoAdyacente(Enlace arista){

listaNodoAdyacente.add(arista);
}
public void addNodoAdyacente(Arista via,Nodo nodo){
this.addNodoAdyacente(new Enlace(via,nodo));
}

28
//Declaracion de setters y getters

public void setVisitado(boolean visitado){

this.visitado = visitado;
}
public boolean isVisitado(){
return visitado;
}

public Circulo getCirculo() {

return circulo;
}

public void setCirculo(Circulo circulo) {

this.circulo = circulo;
}

public int getLongitudCamino() {

return longitudCamino;
}

public void setLongitudCamino(int longitudCamino) {

this.longitudCamino = longitudCamino;
}

public boolean isMarca() {

return marca;

29
 }

public void setMarca(boolean marca) {

this.marca = marca;
}

public Nodo getNodoAntecesorDisjktra() {

return nodoAntecesorDisjktra;
}

public void setNodoAntecesorDisjktra(Nodo nodoAntecesorDisjktra) {

this.nodoAntecesorDisjktra = nodoAntecesorDisjktra;
}
}

Clase disjktra

package operaciones;
//importación de librerias

import java.awt.Color;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import javax.swing.JTextArea;
import objetos.Arista;
import objetos.Enlace;
import objetos.Grafo;
import objetos.Nodo;

30
import static ventana.Historial.historial;

public class Disjktra {

//Declaracion variables

Grafo grafo;
ListaNodo listaNodosAdyacentes;
ArrayList<Arista> aux = new ArrayList<Arista>();
//Declaracion del constructor

public Disjktra(Grafo grafo) {

this.grafo = grafo;
listaNodosAdyacentes = new ListaNodo();
}
//Metodo para llenar los nodos

private void llenarConAdyacentes(Nodo nodo) {

if (nodo != null) {
ArrayList<Enlace> listaAux = nodo.getListaNodoAdyacente();
if (listaAux != null) {
for (Enlace enlace : listaAux) {
Nodo aux2 = enlace.getNodo();
if (!aux2.isMarca()) {

if (listaNodosAdyacentes.isContenido(aux2)) {
int longitud = nodo.getLongitudCamino() +
enlace.getArista().getPeso();
if (aux2.getLongitudCamino() > longitud) {
aux2.setLongitudCamino(longitud);

31
 aux2.setNodoAntecesorDisjktra(nodo);
}
} else {
aux2.setLongitudCamino(nodo.getLongitudCamino() +
enlace.getArista().getPeso());
aux2.setNodoAntecesorDisjktra(nodo);
listaNodosAdyacentes.add(aux2);
}

}
}
}
}
}
//Metodo de ejecución de nodos

public void ejecutar(Nodo nodoInicio) {

nodoInicio.setLongitudCamino(0);
if (nodoInicio != null) {
listaNodosAdyacentes = new ListaNodo();
listaNodosAdyacentes.add(nodoInicio);
while (!listaNodosAdyacentes.isEmpty()) {
Nodo menor = listaNodosAdyacentes.buscarMenor();
menor.setMarca(true);
listaNodosAdyacentes.remove(menor);
llenarConAdyacentes(menor);
}
}

32
 }
//Metodo para encontrar la ruta corta

private void rutaCorta(Nodo nodoFinal) {

aux.clear();
Nodo nAux = nodoFinal;
while (nAux.getNodoAntecesorDisjktra() != null) {
// aux.add(grafo.getArista(nAux.getCapital().getNombreCiudad(),
//
nAux.getNodoAntecesorDisjktra().getCapital().getNombreCiudad()));
aux.add(grafo.getArista(nAux,
nAux.getNodoAntecesorDisjktra()));
nAux = nAux.getNodoAntecesorDisjktra();
}

}
//Metodo para marcar la mas corta

public int marcarRutaCorta(Nodo nodoFinal, Color color) {

int peso = 0;
String a="INICIO RUTA";
historial.texto(a);
if (nodoFinal != null) {
rutaCorta(nodoFinal);
for (int i = 0; i < aux.size(); i++) {
if (!aux.isEmpty()) {
peso += aux.get(i).getPeso();
//System.out.println("Estacion : " + aux.get(i).getNombreArista()
+ "\t\t\tDistancia : " + aux.get(i).getPeso() +" mts.");

33
 a = "Estacion : " + aux.get(i).getNombreArista() + "\t\tDistancia :
" + aux.get(i).getPeso() +" mts.";
System.out.println(a);
historial.texto(a);
aux.get(i).getLineaQuebrada().setColor(color);
aux.get(i).getLineaQuebrada().setGrosorLinea(5);
}
}
}
return peso;
}
}

Clase Lista nodo

package operaciones;
//Importacion de librerias

import java.util.ArrayList;
import objetos.Nodo;
//usando extends se hereda el arrayList

public class ListaNodo extends ArrayList<Nodo>{

//Declarar el constructor

public ListaNodo(){
super();
}
//Metodo para buscar el menor camino

public Nodo buscarMenor(){

34
 Nodo aux = new Nodo();
aux.setLongitudCamino(9999999);

for(Nodo nodo:this){
if(nodo.getLongitudCamino() < aux.getLongitudCamino()){
aux = nodo;
}
}

return aux;
}
//Metodo para el contenido del nodo

public boolean isContenido(Nodo nodo){

boolean retornado = false;
for(Nodo n:this){
if(n == nodo){
retornado = true;
}
}
return retornado;
}
}

Código de la interfaz

Clase GUI

35
package ventana;

import java.awt.Color;
import java.util.ArrayList;
import java.util.Arrays;
import javax.swing.JCheckBox;
import javax.swing.JOptionPane;
import objetos.*;
import operaciones.Disjktra;
import static ventana.Historial.historial;

public class Gui extends javax.swing.JFrame {

//Declaracion de variables

Grafo grafo = new Grafo();

Nodo nodoInicio = null;
Nodo nodoFin = null;
//Creamos el form

public Gui() {
initComponents();
//Tutorial();
}

@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
//Declaracion de arreglos

36
 private void initComponents() {

jPanel2 = new javax.swing.JPanel();

jPanel1 = new javax.swing.JPanel();
jButton1 = new javax.swing.JButton();
jButton2 = new javax.swing.JButton();
jButton3 = new javax.swing.JButton();
jButton4 = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOS
E);

jPanel2.setBorder(javax.swing.BorderFactory.createTitledBorder("Grafo
Caminos Minimos"));
jPanel2.setFocusTraversalPolicyProvider(true);

jPanel1.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
jPanel1MouseClicked(evt);
}
});
jPanel1.setLayout(new org.netbeans.lib.awtextra.AbsoluteLayout());

jButton1.setText("Estacion");
jButton1.addActionListener(new java.awt.event.ActionListener() {

37
 public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});
jPanel1.add(jButton1, new
org.netbeans.lib.awtextra.AbsoluteConstraints(1080, 580, 91, -1));

jButton2.setText("Enlazar");
jButton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton2ActionPerformed(evt);
}
});
jPanel1.add(jButton2, new
org.netbeans.lib.awtextra.AbsoluteConstraints(1080, 620, 91, -1));

jButton3.setText("Tutorial");
jButton3.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton3ActionPerformed(evt);
}
});
jPanel1.add(jButton3, new
org.netbeans.lib.awtextra.AbsoluteConstraints(1180, 10, 91, 30));

jButton4.setText("Historial");
jButton4.addActionListener(new java.awt.event.ActionListener() {

38
 public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton4ActionPerformed(evt);
}
});
jPanel1.add(jButton4, new
org.netbeans.lib.awtextra.AbsoluteConstraints(1210, 620, -1, -1));

jLabel1.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/ventana/MapaMetroOficia
l.png"))); // NOI18N
jPanel1.add(jLabel1, new
org.netbeans.lib.awtextra.AbsoluteConstraints(0, 0, 1290, 670));
jLabel1.getAccessibleContext().setAccessibleParent(this);

javax.swing.GroupLayout jPanel2Layout = new

javax.swing.GroupLayout(jPanel2);
jPanel2.setLayout(jPanel2Layout);
jPanel2Layout.setHorizontalGroup(

jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LE
ADING)
.addComponent(jPanel1,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
);
jPanel2Layout.setVerticalGroup(

jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LE
ADING)

39
 .addComponent(jPanel1,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
);

getContentPane().add(jPanel2, java.awt.BorderLayout.CENTER);

pack();
}// </editor-fold>

private void jPanel1MouseClicked(java.awt.event.MouseEvent evt) {

int x = evt.getX();
int y = evt.getY();
if (evt.isMetaDown()) {
if (grafo.buscarNodo(x, y) != null) {//si se hace clic sobre un nodo
if (nodoInicio == null) {
nodoInicio = grafo.buscarNodo(x, y);//nodoInicio lo pongo a
apuntar al nodo donde hice clic
nodoInicio.getCirculo().setColor(Color.red);//Lo hago cambiar
de color
} else if (grafo.buscarNodo(x, y) == nodoInicio) {//si selecciona el
mismo nodo este se elimina
eliminarNodo(x, y);
nodoInicio = null;
} else {//si nodoInicio ya estaba apunto a un nodo, lo preparo para
crear arista
nodoFin = grafo.buscarNodo(x, y);
crearArista();

40
 nodoInicio.getCirculo().setColor(Color.yellow);//lo regreso a su
color original
nodoInicio = null;//null para poder crear mas arista
nodoFin = null;//null para poder crear mas arista
}
} else {//Si no he hecho clic sobre un nodo
crearNodo(x, y);//creo un nodo apartir de unas coordenadas
}
dibujarGrafo();
} else {
if (grafo.buscarNodo(x, y) != null) {//si se hace clic sobre un nodo
if (nodoInicio == null) {
grafo.reiniciarGrafoParaDisjktra();
grafo.reiniciarColores();
nodoInicio = grafo.buscarNodo(x, y);//nodoInicio lo pongo a
apuntar al nodo donde hice clic
nodoInicio.getCirculo().setColor(Color.red);//Lo hago cambiar
de color<
dibujarNodos();
//JOptionPane.showMessageDialog(null,"Seleccione otro nodo
para buscar camino mas corto");
} else {//si nodoInicio ya estaba apunto a un nodo, lo preparo para
crear arista
nodoFin = grafo.buscarNodo(x, y);
Disjktra disjktra = new Disjktra(grafo);
disjktra.ejecutar(nodoInicio);
int tem = disjktra.marcarRutaCorta(nodoFin, Color.red);
dibujarArista();

41
 String aux;
double t =tem/8.307;
t= t/60;
int tiempo=(int)t;
aux = "Distancia total : " + tem+" metros \t\tTiempo Aprox. :
"+tiempo+" minutos";
System.out.println(aux);
historial.texto(aux);
JOptionPane.showMessageDialog(null, "Distancia total : " +
tem+" Metros. \nTiempo Aprox. : "+tiempo+" minutos");
nodoInicio = null;//null para poder crear mas arista
nodoFin = null;//null para poder crear mas arista
dibujarGrafo();
}
}
}
}

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

estacionesMetro();
dibujarNodos();
}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {

enlazarMetro();
nodoInicio=null;
dibujarArista();

42
}

private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {

Tutorial(); // TODO add your handling code here:
}

private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) {

historial.setVisible(true);// TODO add your handling code here:
}
public void dibujarGrafo() {
jPanel1.paint(jPanel1.getGraphics());
dibujarArista();
dibujarNodos();
}

public void dibujarNodos() {

ArrayList<Nodo> listaNodo = grafo.getListaNodos();
for (Nodo nodo : listaNodo) {
nodo.getCirculo().dibujarCirculo(jPanel1.getGraphics());
}
}

public void dibujarArista() {

ArrayList<Nodo> listaNodo = grafo.getListaNodos();
for (Nodo nodo : listaNodo) {
ArrayList<Enlace> listaEnlace = nodo.getListaNodoAdyacente();
if (listaEnlace != null) {

43
 for (Enlace enlace : listaEnlace) {

enlace.getArista().getLineaQuebrada().dibujarLineaQuebrada(jPanel1.getG
raphics());
}
}
}
}

private int ingresarPeso() {

String peso = JOptionPane.showInputDialog("Digite la distancia entre
puntos");
int intPeso = 0;
try {
intPeso = Integer.parseInt(peso);
} catch (Exception ex) {
intPeso = ingresarPeso();
}
return intPeso;
}

private void eliminarNodo(int x, int y) {

if (grafo.buscarNodo(x, y) != null) {//si se hace clic sobre un nodo
Nodo temp = grafo.buscarNodo(x, y);

if (grafo.buscarNodo(x, y).getListaNodoAdyacente() != null &&

grafo.buscarNodo(x, y).getListaNodoAdyacente().size() != 1) {
int coorX[];

44
 coorX = new int[temp.getListaNodoAdyacente().size()];
int Dis[];
Dis = new int[temp.getListaNodoAdyacente().size()];
int coorY[];
coorY = new int[temp.getListaNodoAdyacente().size()];
for (int i = 0; i < temp.getListaNodoAdyacente().size(); i++) {
coorX[i] =
temp.getListaNodoAdyacente().get(i).getNodo().getCirculo().getX();
coorY[i] =
temp.getListaNodoAdyacente().get(i).getNodo().getCirculo().getY();
Dis[i] = grafo.getArista(buscar(coorX[i], coorY[i]).getDato(),
temp.getDato()).getPeso();
}
grafo.eliminarAristas(temp);
for (int i = 0; i < coorX.length; i = i + 2) {

nodoInicio = buscar(coorX[i], coorY[i]);

nodoFin = buscar(coorX[i + 1], coorY[i + 1]);
aristaMetro(Dis[i] + Dis[i + 1], nodoInicio, nodoFin);
}
if (grafo.eliminarNodo(temp)) {
JOptionPane.showMessageDialog(null, "Eliminado");
}
} else {
grafo.eliminarAristas(temp);
if (grafo.eliminarNodo(temp)) {
JOptionPane.showMessageDialog(null, "Eliminado");

45
 }
}
}
}

private void crearArista() {

int intPeso = ingresarPeso();
Arista arista = new Arista();
arista.setPeso(intPeso);
Coordenadas c = new Coordenadas(100000, 100000);
c.addCoordenada(nodoInicio.getCirculo().getX() +
(nodoInicio.getCirculo().getDiametro() / 2), nodoInicio.getCirculo().getY() +
(nodoInicio.getCirculo().getDiametro() / 2));
c.addCoordenada(nodoFin.getCirculo().getX() +
(nodoInicio.getCirculo().getDiametro() / 2), nodoFin.getCirculo().getY() +
(nodoInicio.getCirculo().getDiametro() / 2));
LineaQuebrada lq = new LineaQuebrada(c);
arista.setLineaQuebrada(lq);
grafo.crearEnlacesNoDirigido(nodoInicio, nodoFin, arista);

private void crearNodo(int x, int y) {

Coordenadas c = new Coordenadas(100000, 100000, x, y);
String dato = JOptionPane.showInputDialog("Digite un dato o Nombre
de la coordenada");
System.out.println("x= " + x + "\ty= " + y + "\tnombre= " + dato);
if (dato != null) {

46
 dato = dato.toUpperCase();//por que lo quiero todo en mayusculas
Nodo nodo = new Nodo(dato, c);
nodo.getCirculo().setDiametro(12);
nodo.getCirculo().setEtiqueta(nodo.getDato() + "");
if (grafo.adjuntarNodo(nodo)) {
nodo.getCirculo().dibujarCirculo(jPanel1.getGraphics());

} else {
}
nodoInicio = null;
nodoFin = null;
}

public void iniciarMetro() {

estacionesMetro();
enlazarMetro();
}

private void nodoMetro(String nombre, int x, int y) {

Coordenadas c = new Coordenadas(100000, 100000, x, y);
Nodo nodo = new Nodo(nombre, c);
nodo.getCirculo().setDiametro(10);
nodo.getCirculo().setEtiqueta(nodo.getDato() + "");
if (grafo.adjuntarNodo(nodo)) {
nodo.getCirculo().dibujarCirculo(jPanel1.getGraphics());

47
 } else {
System.out.println("Nodo F");
}
//dibujarNodos();
}

private void aristaMetro(int intPeso, Nodo nodoInicio, Nodo nodoFin) {

Arista arista = new Arista();
arista.setPeso(intPeso);
Coordenadas c = new Coordenadas(100000, 100000);
if (nodoInicio != null) {
c.addCoordenada(nodoInicio.getCirculo().getX() +
(nodoInicio.getCirculo().getDiametro() / 2), nodoInicio.getCirculo().getY() +
(nodoInicio.getCirculo().getDiametro() / 2));
}

if (nodoFin != null) {
c.addCoordenada(nodoFin.getCirculo().getX() +
(nodoFin.getCirculo().getDiametro() / 2), nodoFin.getCirculo().getY() +
(nodoFin.getCirculo().getDiametro() / 2));
}

LineaQuebrada lq = new LineaQuebrada(c);

arista.setLineaQuebrada(lq);
arista.setNombreArista(nodoInicio.getDato() + "-" + nodoFin.getDato());
grafo.crearEnlacesNoDirigido(nodoInicio, nodoFin, arista);
//dibujarArista();
}

48
 private void lineaB(){
int[]
coorX={28,60,102,136,205,255,308,358,413,434,480,501,524,541,582,530
,513,511,503,501,496};
int[]
coorY={37,45,59,68,87,99,112,126,146,175,214,232,257,278,318,332,353,
374,400,420,442};
String[] name={"Ciudad Azteca","Plaza
Arago","Olimpica","Ecatepec","Muzquiz","R.d.l. Remedios",
"Impulsora","Nezahualcoyotl","Villa de Aragon","B. de
aragon","Dept. Oceania","Oceania",
"Romero Rubio","Flores magon","San
Lazaro","Morelos","Tepito","Lagunilla","Garibaldi","Guerrero","Buenavista"};
for(int i=0; i<coorX.length; i++){
nodoMetro(name[i], coorX[i], coorY[i]);
}
}
private void lineaA(){
int[] coorX={663,718,753,793,843,904,953,1006,1039,1050};
int[] coorY={184,179,138,99,89,78,70,60,50,31};
String[] name={"Pantitlan","Agricola Ori.","C. de San
Juan","Tepalcates",
"Guelatao","Peñon Viejo","Acatitla","Santa Marta","Los
Reyes","La Paz"};
for(int i=0; i<coorX.length; i++){
nodoMetro(name[i], coorX[i], coorY[i]);
}
}
private void linea1(){

49
 int[]
coorX={746,729,677,637,629,618,604,599,601,603,604,603,596,603,624,6
41,658,683};
int[]
coorY={598,556,543,525,507,478,448,430,406,396,379,355,334,302,280,2
62,240,214};
String[]
name={"Observatorio","Tacubaya","Juanacatlan","Chapultepec","Sevilla","I
nsurgente",
"Cuauhtemoc","Balderas","Ojo de Agua","Isabel la
Catol.","Pino suarez","Merced","Candelaria",
"Moctezuma","Balbuena","Boulevard Pto.","Gomez
Farias","Zaragoza"};
for(int i=0; i<coorX.length; i++){
nodoMetro(name[i], coorX[i], coorY[i]);
}
}
private void linea2(){
int[]
coorX={421,420,423,441,463,487,510,524,536,543,549,555,571,658,697,7
40,773,810,851,906,949,995,1038};
int[]
coorY={646,611,566,532,515,501,486,467,444,423,402,388,377,384,388,3
93,397,400,404,409,412,422,411};
String[] name={"Cuatro
Cam.","Panteones","Tacuba","Cuitlahuac","Popotla","Colegio
Militar","Normal","San Cosme",
"Revolucion","Hidalgo","Bellas artes","Allende","Zocalo","San
Antonio","Chabacano","Viaducto","Xola",
"Villa cortes","Nativitas","Portales","Ermita","General
Anaya","Tasqueña"};

50
 for(int i=0; i<coorX.length; i++){
nodoMetro(name[i], coorX[i], coorY[i]);
}
}
private void linea3(){
int[]
coorX={237,294,329,364,452,566,644,677,707,767,822,856,899,955,991,1
026,1087,1142};
int[]
coorY={337,356,374,391,416,428,437,448,452,456,461,466,483,504,521,5
34,526,517};
String[] name={"Indios Verdes","Dept 18 de Mar","Potrero","La
Raza","Tlatelolco","Juarez",
"Niños Heroes","Hospital
genl","Centromedico","Etiopia","Eugenia","Div. Del Norte",
"Zapata","Coyoacan","Viveros","Miguel A. d.
Q.","Copilco","Universidad"};
for(int i=0; i<coorX.length; i++){
nodoMetro(name[i], coorX[i], coorY[i]);
}
}
private void linea4(){
int[] coorX={293,351,400,449,481,629,694,716};
int[] coorY={287,299,310,316,323,338,342,343};
String[] name={"Martin
Carrera","Talisman","Bondojito","Consulado","C. del Norte",
"Fray Servando","Jamaica","Santa Anita"};
for(int i=0; i<coorX.length; i++){
nodoMetro(name[i], coorX[i], coorY[i]);

51
 }
}
private void linea5(){
int[] coorX={207,257,322,412,431,471,468,566,619};
int[] coorY={433,419,405,362,335,287,254,234,228};
String[] name={"Politecnico","Inst. Petroleo","Auto.
Norte","Misterios","Valle Gomes",
"Eduardo molina","Aragon","Terminal Aerea","Hangares"};
for(int i=0; i<coorX.length; i++){
nodoMetro(name[i], coorX[i], coorY[i]);
}
}
private void linea6(){
int[] coorX={196,236,262,256,271,259,272,309};
int[] coorY={592,574,552,512,471,452,382,333};
String[]
name={"Rosario","Tezozomoc","Azcapozalco","Ferreria","Norte
45","Vallejo",
"Lindavista","Basilica"};
for(int i=0; i<coorX.length; i++){
nodoMetro(name[i], coorX[i], coorY[i]);
}
}
private void linea7(){
int[] coorX={259,319,365,500,564,604,681,787,824,869,939};
int[] coorY={581,560,563,571,569,572,569,554,554,560,565};
String[] name={"Aqui. Serdan","Camarones","Refineria","San
Joaquin","Polanco",

52
 "Auditorio","Constituyentes","Sn. Pedro Pinos","Sn.
Antonio","Mixcoac","Barranca M."};
for(int i=0; i<coorX.length; i++){
nodoMetro(name[i], coorX[i], coorY[i]);
}
}
private void linea8(){
int[]
coorX={577,631,673,711,756,810,851,888,927,981,967,987,1010,1037};
int[]
coorY={405,414,416,359,317,313,306,300,303,286,242,218,187,150};
String[] name={"Sn. Juan Letran","Doctores","Obrera","La
viga","Coyuya","Iztacalco","Apalco",
"Aculco","Escu.201","Atlalilco","Iztapalapa","C.
Estrella","U.A.M","Const. 1917"};
for(int i=0; i<coorX.length; i++){
nodoMetro(name[i], coorX[i], coorY[i]);
}
}
private void linea9(){
int[] coorX={709,707,703,697,701,701,708};
int[] coorY={530,494,419,315,283,233,207};
String[] name={"Patriotismo","Chilpancingo","Lazaro
Card.","Mixoca","Velodromo","Cd. Deportiva","Puebla"};
for(int i=0; i<coorX.length; i++){
nodoMetro(name[i], coorX[i], coorY[i]);
}
}

53
 private void linea12(){
int[]
coorX={882,893,923,946,968,1055,1103,1138,1143,1152,1177,1186,1196,
1205,1214,1263};
int[]
coorY={534,508,456,439,344,296,299,278,247,219,197,163,133,107,81,65
};
String[] name={"Insurgente S.","H. 20 de Nov.","Parq. Venados","Eje
Central","Mexicaltzingo","Culhuacan",
"Sn Andres T.","L. Estrella","Calle 11","Periferico
Ote","Tezonco","olivos","Nopalera",
"Zapotitlan","Taltengo","Tlahuac"};
for(int i=0; i<coorX.length; i++){
nodoMetro(name[i], coorX[i], coorY[i]);
}
}

private void estacionesMetro() {

lineaB(); lineaA(); linea1(); linea2(); linea3(); linea4(); linea5();
linea6(); linea7(); linea8(); linea9(); linea12();

private Nodo buscar(int x, int y) {

Nodo aux = null;
int x2, y2;
for (int i = 0; i < grafo.getListaNodos().size(); i++) {
aux = grafo.getListaNodos().get(i);

54
 x2 = aux.getCirculo().getX();
y2 = aux.getCirculo().getY();
if (x2 == x && y2 == y) {
return aux;
}
}
return null;
}
private void EnlazarB(){
int[]
coorX={28,60,102,136,205,255,308,358,413,434,480,501,524,541,582,530
,513,511,503,501,496};
int[]
coorY={37,45,59,68,87,99,112,126,146,175,214,232,257,278,318,332,353,
374,400,420,442};
int[]
Distancia={0,574,709,596,1485,1155,436,1393,1335,784,1165,863,809,90
8,907,1296,498,611,474,757,521};
for(int i=1; i<coorX.length; i++){
nodoInicio=buscar(coorX[i-1],coorY[i-1]);
nodoFin=buscar(coorX[i],coorY[i]);
aristaMetro(Distancia[i],nodoInicio,nodoFin);
}
}
private void EnlazarA(){
int[] coorX={663,718,753,793,843,904,953,1006,1039,1050};
int[] coorY={184,179,138,99,89,78,70,60,50,31};
int[] Distancia={0,1409,1093,1456,1161,2206,1379,1100,1783,1956};
for(int i=1; i<coorX.length; i++){

55
 nodoInicio=buscar(coorX[i-1],coorY[i-1]);
nodoFin=buscar(coorX[i],coorY[i]);
aristaMetro(Distancia[i],nodoInicio,nodoFin);
}
}
private void Enlazar1(){
int[]
coorX={746,729,677,637,629,618,604,599,601,603,604,603,596,582,603,6
24,641,658,683,663};
int[]
coorY={598,556,543,525,507,478,448,430,406,396,379,355,334,318,302,2
80,262,240,214,184};
int[]
Distancia={0,1320,762,611,596,703,478,866,698,745,382,445,458,409,793
,645,501,973,1158,1262};
for(int i=1; i<coorX.length; i++){
nodoInicio=buscar(coorX[i-1],coorY[i-1]);
nodoFin=buscar(coorX[i],coorY[i]);
aristaMetro(Distancia[i],nodoInicio,nodoFin);
}
}
private void Enlazar2(){
int[]
coorX={421,420,423,441,463,487,510,524,536,543,549,555,571,604,658,6
97,740,773,810,851,906,949,995,1038};
int[]
coorY={646,611,566,532,515,501,486,467,444,423,402,388,377,379,384,3
88,393,397,400,404,409,412,422,411};
int[]
Distancia={0,1639,1416,637,620,462,516,657,537,587,447,387,602,745,81
7,642,774,490,698,750,924,748,838,1330};

56
 for(int i=1; i<coorX.length; i++){
nodoInicio=buscar(coorX[i-1],coorY[i-1]);
nodoFin=buscar(coorX[i],coorY[i]);
aristaMetro(Distancia[i],nodoInicio,nodoFin);
}
}
private void Enlazar3(){
int[]
coorX={237,294,329,364,452,501,543,566,599,644,677,707,767,822,856,8
99,955,991,1026,1087,1142};
int[]
coorY={337,356,374,391,416,420,423,428,430,437,448,452,456,461,466,4
83,504,521,534,526,517};
int[]
Distancia={0,1166,966,1106,1445,1042,702,251,659,665,559,653,1119,95
0,715,794,1153,908,824,1295,1306};
for(int i=1; i<coorX.length; i++){
nodoInicio=buscar(coorX[i-1],coorY[i-1]);
nodoFin=buscar(coorX[i],coorY[i]);
aristaMetro(Distancia[i],nodoInicio,nodoFin);
}
}
private void Enlazar4(){
int[] coorX={293,351,400,449,481,530,596,629,694,716};
int[] coorY={287,299,310,316,323,332,334,338,342,343};
int[] Distancia={0,758,1033,633,1062,910,884,645,959,1129};
for(int i=1; i<coorX.length; i++){
nodoInicio=buscar(coorX[i-1],coorY[i-1]);
nodoFin=buscar(coorX[i],coorY[i]);
aristaMetro(Distancia[i],nodoInicio,nodoFin);

57
 }
}
private void Enlazar5(){
int[] coorX={207,257,322,412,431,471,468,501,566,619,663};
int[] coorY={433,419,405,362,335,287,254,232,234,228,184};
int[]
Distancia={0,1188,1067,975,892,969,679,815,860,1219,1174,1153,1644};
for(int i=1; i<coorX.length; i++){
nodoInicio=buscar(coorX[i-1],coorY[i-1]);
nodoFin=buscar(coorX[i],coorY[i]);
aristaMetro(Distancia[i],nodoInicio,nodoFin);
}
}
private void Enlazar6(){
int[] coorX={196,236,262,256,271,259,257,272,294,309,293};
int[] coorY={592,574,552,512,471,452,419,382,356,333,287};
int[] Distancia={0,1257,973,1173,1072,660,755,1258,1075,570,1141};
for(int i=1; i<coorX.length; i++){
nodoInicio=buscar(coorX[i-1],coorY[i-1]);
nodoFin=buscar(coorX[i],coorY[i]);
aristaMetro(Distancia[i],nodoInicio,nodoFin);
}
}
private void Enlazar7(){
int[]
coorX={196,259,319,365,423,500,564,604,681,729,787,824,869,939};
int[]
coorY={592,581,560,563,566,571,569,572,569,556,554,554,560,565};

58
 int[]
Distancia={0,1615,1402,952,1295,1433,1163,812,1430,1005,1084,606,788
,1476};
for(int i=1; i<coorX.length; i++){
nodoInicio=buscar(coorX[i-1],coorY[i-1]);
nodoFin=buscar(coorX[i],coorY[i]);
aristaMetro(Distancia[i],nodoInicio,nodoFin);
}
}
private void Enlazar8(){
int[]
coorX={503,549,577,601,631,673,697,711,756,810,851,888,927,981,967,9
87,1010,1037};
int[]
coorY={400,402,405,406,414,416,388,359,317,313,306,300,303,286,242,2
18,187,150};
int[]
Distancia={0,634,456,292,564,761,1143,843,633,968,993,910,534,789,173
8,732,717,1135,1137};
for(int i=1; i<coorX.length; i++){
nodoInicio=buscar(coorX[i-1],coorY[i-1]);
nodoFin=buscar(coorX[i],coorY[i]);
aristaMetro(Distancia[i],nodoInicio,nodoFin);
}
}
private void Enlazar9(){
int[] coorX={729,709,707,707,703,697,694,697,701,701,708,663};
int[] coorY={556,530,494,452,419,388,342,315,283,233,207,184};
int[]
Distancia={0,1380,800,1110,821,942,1031,1000,1059,1152,955,1133};

59
 for(int i=1; i<coorX.length; i++){
nodoInicio=buscar(coorX[i-1],coorY[i-1]);
nodoFin=buscar(coorX[i],coorY[i]);
aristaMetro(Distancia[i],nodoInicio,nodoFin);
}
}
private void Enlazar12(){
int[]
coorX={869,882,893,899,923,946,949,968,981,1055,1103,1138,1143,1152
,1177,1186,1196,1205,1214,1263};
int[]
coorY={560,534,508,483,456,439,412,344,286,296,299,278,247,219,197,1
63,133,107,81,65};
int[]
Distancia={0,1298,1115,1276,1360,490,1545,1111,906,1060,990,1671,192
2,1805,895,1280,563,450,725,651};
for(int i=1; i<coorX.length; i++){
nodoInicio=buscar(coorX[i-1],coorY[i-1]);
nodoFin=buscar(coorX[i],coorY[i]);
aristaMetro(Distancia[i],nodoInicio,nodoFin);
}
}

private void enlazarMetro() {

Nodo nodoInicio = null, nodoFin = null;
EnlazarB(); EnlazarA(); Enlazar1(); Enlazar2(); Enlazar3(); Enlazar4();
Enlazar5();
Enlazar6(); Enlazar7(); Enlazar8(); Enlazar9(); Enlazar12();

60
 public void Tutorial(){
String[] option={"Creditos","Salir"};
JCheckBox check = new JCheckBox();
JOptionPane.showMessageDialog(rootPane, "Bienvenidos a nuestra
aplicación [Camino Minimo]. \n"
+ "En este programa se determinara el camino más corto de una\n
"
+ "estación a otra.\n A continuación se mostrara un pequeño
tutorial para aprender \n"
+ "como usar este servicio.", "Tutorial",
JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(null,"Dentro del programa hay 2
botones que son importantes para el\n"
+ "correcto funcionamiento de la aplicación.\n-ESTACION- Nos
muestra las estaciones del metro.\n"
+ "-ENLAZAR- Une a todas las lineas del metro.\n Es importante
el orden en que se utilizan estos "
+ "botones.\n ESTACION >>> ENLAZAR", "Tutorial",
JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(rootPane,"Para ingresar el punto de
partida solo debe seleccionar con\n"
+ "click izquierdo de su Mouse algunos de los puntos en el
mapa.\nPara ingresar el punto de llegada "
+ "debe repetir los pasos anteriores.", "Tutorial",
JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(rootPane,"Si alguna estación se
encuentra en reparación o se encuentra\n"
+ "fuera de servicio puede eliminarla de su posible
recorrido.\nSelecciona la estación con click"

61
 + "izquierdo del mouse y con click derecho la elimina.
","Tutorial",JOptionPane.INFORMATION_MESSAGE);
int x =JOptionPane.showOptionDialog(rootPane,"Hemos llegado al
final de este tutorial.\n"
+ "Deseamos que disfrute el servicion.", "Fin del
Tutorial",JOptionPane.DEFAULT_OPTION,JOptionPane.INFORMATION_
MESSAGE,
null,option,option[0]);

if(x==0){
JOptionPane.showMessageDialog(rootPane, "-> José Uriel Lopez
Sanchez. <-\n"
+ "-> Gerardo Leonardo Santana Islas. <-\n-> Ana Laura Terres
Reyes. <-\n-> Enrique Valaguez Manjarre. <-\n"
+ "", "Creditos",JOptionPane.INFORMATION_MESSAGE);}

public static void main(String args[]) {

try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}

62
 } catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(Gui.class.getName()).log(java.util.loggin
g.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {

java.util.logging.Logger.getLogger(Gui.class.getName()).log(java.util.loggin
g.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(Gui.class.getName()).log(java.util.loggin
g.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {

java.util.logging.Logger.getLogger(Gui.class.getName()).log(java.util.loggin
g.Level.SEVERE, null, ex);
}

java.awt.EventQueue.invokeLater(new Runnable() {

@Override
public void run() {
new Gui().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;

63
 private javax.swing.JButton jButton3;
private javax.swing.JButton jButton4;
private javax.swing.JLabel jLabel1;
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
}

Clase historial

package ventana;
//uso de extends para heredar métodos y variables

public class Historial extends javax.swing.JFrame {

//Declaracion de arreglo

public static Historial historial = new Historial();

//Crear el form del historial

public Historial() {
initComponents();
}
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {

jScrollPane1 = new javax.swing.JScrollPane();

jTextPane1 = new javax.swing.JTextPane();

64
setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_C
LOSE);
setTitle("Historial");

jTextPane1.setEditable(false);
jScrollPane1.setViewportView(jTextPane1);

javax.swing.GroupLayout layout = new

javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addComponent(jScrollPane1,
javax.swing.GroupLayout.PREFERRED_SIZE, 647,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(0, 0, Short.MAX_VALUE))
);
layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jScrollPane1,
javax.swing.GroupLayout.DEFAULT_SIZE, 300, Short.MAX_VALUE)
);

pack();
}// </editor-fold>

65
 public void texto(String a){
String aux = jTextPane1.getText()+"\n"+a;
jTextPane1.setText(aux);
}

// Variables declaration
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTextPane jTextPane1;
}

66
Manual de uso del programa

1- Para poder usar el programa es necesario tener el

NetBeans funcionando con el programa abierto, al
tenerlo en función ejecutamos el código.

Presionar
para ejecutar

2- Al ejecutar el programa, mostrara una interfaz

donde se vera el mapa del metro junto a botones
que cumplen una función específica.

67
 Boton

Pantalla de

ejecución

Boton
Boton

Boton

3-Presionando en el botón con el nombre de

“Tutorial”.

Presionar
.

Al ser presionado lanza un mensaje la función del

programa y un saludo, a continuación, mostrara el
tutorial.

68
 Presionar

Al presionar el botón “Aceptar”, muestra otra

pantalla con el mensaje de como usar el programa
y las funciones de los botones.

Presionar

Siguiendo el tutorial muestra cómo realizar el

recorrido y obtener el camino más corto.

69
 Presionar

Al dar aceptar nos mostrara el final del tutorial el

cual muestra un mensaje para el usuario y
muestra dos opciones, una para salir y otra para
los créditos del programa.

Presionar

Presionar

3.1- Presionando el botón “Créditos”.

70
 Presionar

Mostrará una pantalla donde serán visibles el

nombre los integrantes del grupo.

Presionar
Presionar aceptar para volver al menú.

4- Después de volver al menú principal, se

presiona el botón “Estaciones”.

71
 Presionar

Comenzara a imprimir los nombres de cada

estación del metro colocando los botones.

Nombres

5-Presionamos el botón “Enlazar”.

72
 Presionar
enlazar nos une todas las estaciones del metro y
nos crea todos los transbordos para ya poder
usar la aplicación e insertar los recorridos.

Transbordo
Transbordo
Transbordo

Traza una línea roja que muestra el camino mas

corto, tomando como ejemplo el camino de la
estación de Ecatepec al zócalo, seguido de una

73
pantalla donde muestra la distancia en metros y el
tiempo estimado.

Realizamos una según prueba, donde nos traza la

trayectoria mas corta y nos muestra los metros y
tiempo.
6-Presionamos el botón “Historial”.

Presionar

74
 Nos aparece una ventana emergente donde nos
muestran todos los viajes que hemos realizado,
con distancia, tiempo y las estaciones que hay
que recorrer para llegar al destino solicitado.

Historial

7-Para eliminar alguna estación, se debe dar

seleccionarlo, para este caso mostraremos
eliminando la estación “Muzquiz”.

75
 Presionar

Nos aparece una ventana donde dice emergente

al dar clic en aceptar o cerrar la ventana la
estación se eliminará del mapa y se conectarán
las estaciones adyacentes para no interrumpir el
paso.
Estación

Presionar

Como podemos ver ya no se muestra la estación

“Muzquiz”.

76
 Estación eliminada

8-Para poner en funcionamiento las estaciones

debe darle click derecho, insertándole un nuevo
nombre

Dar click

77
Al dar clic derecho en donde iba la estación
“Muzquiz” nos aparece la siguiente ventana para
poder volver a poner la estación en
funcionamiento, nos pide insertar un nombre y en
este caso pondremos el de la estación que
eliminamos.

Nombramiento
de la estación

Presionar

78
Aquí podemos ver como ya se ha insertado la
estación después de dar clic en aceptar, pero
cuidado porque aún no hemos enlazado las
estaciones adyacentes así que no podemos
usarla aún por lo que debemos enlazarla e insertar
el valor de las distancias para poder usarla.

Estaciones agregadas

9-Al presionar sobre las estaciones agregadas,

nos muestra una pantalla donde nos piden la
distancia entre ellas para poder hacer funcional a
ambas estaciones.

Pantalla
colocar
la distancia

Presionar después
de colocar el dato
79
 Conclusiones

Conclusión.
En la realización de este proyecto usando el algoritmo Dijkstra, que es un
algoritmo de búsqueda para determinar la ruta mínima entre los vértices de un
grafo. Este algoritmo tiene una serie de aplicaciones una de las principales
áreas de aplicación es en la telemática ya que permite resolver grafos
complejos con una gran cantidad de nodos, esto para determinar el camino
más corto entre los nodos de una red. Para este proyecto hicimos un uso
práctico de este algoritmo, implementándolo en el mapa del metro de la ciudad
de México y determinar que recorrido realizar para desplazarnos a cualquier
estación dentro de este.
By: Sanchez Lopez Jose Uriel

Conclusión.
Durante el desarrollo de este proyecto comencé a comprender el algoritmo
Dijkstra el cual me ha dado una herramienta para futuros programas y trabajos
en algún futuro. Este tipo de temas me han mostrado la gama de soluciones a
problemas que vivimos día a día, por ello en este programa se acordó resolver
una problemática común, el cual es el uso del transporte colectivo metro, para
recorrer el menor camino, así satisfaciendo la necesidad de optimización de
tiempo-distancia en el uso de este trasporte.
By: Santana Islas Gerardo Leonardo

Conclusión.
El algoritmo Dijkstra es muy útil y se puede aplicar a centros de distribución,
transporte, logística y otros servicios donde se tenga que utilizar el camino más
corto. El servicio de Metro es la vía de transporte más utilizada dentro de la
CDMX y es conveniente el uso de nuestra aplicación para que de ese modo
realice de la manera más óptima y eficiente su traslado. Es importante que en
este documento se aclare el funcionamiento de nuestro programa para
despejar cualquier duda y se dé como resolución que es conveniente su uso y
sobre todo que prosiga las mejoras hacia el mismo.

80
By: Terres Reyes Ana Laura

Conclusión
Los grafos son de mucha utilidad y muy usados en la actualidad en muchos
ámbitos , por ejemplo se usan en biología en estudios de ecosistemas, también
son usados en la sociedad en cómo están estructuradas las relaciones de las
personas este ejemplo se puede ver claro en Facebook donde incluso en la
página de inicio de sesión se puede ver un mini mapa del mundo con varias
personas relacionadas por líneas punteadas , una clara representación de un
grafo a una escala inmensa , también y mayormente se asocia a la realización
de viajes específicamente a la búsqueda de un camino más corto para la
optimización de recursos , esto es empleado en desde lo más simple en cómo
llegar de un punto de una ciudad a otro ,moverse en metro o hasta planificación
de trayectorias para la distribución de mercancía de las grandes empresas o
la planificación de vuelos haciendo un tiempo estimado de vuelo entre el origen
y destino ya sea que tenga escalas o no usando datos como las horas de salida
de todos los vuelos , sus destinos , escalas para lograr la mejor ruta, en este
caso el uso del algoritmo Dijkstra nos ayuda con esa tarea a la hora de hacer
planificaciones de trayectorias ya que bien implementado ahorra recursos pero
el más importante Tiempo
By. Enrique Valaguez Manjarrez

81
Bibliografía

1- A. M. Vozmediano. (20 de junio de 2017). Java para novatos: Cómo

aprender programación orientada a objetos con Java sin desesperarse
en el intento: Volume 3 (Español) Tapa blanda. Mexico: CreateSpace
Independent Publishing Platform.
2- Bruce Eckel. (26 de Enero del 2018). Piensa en Java. Facultad de
Ingeniería Universidad de Deusto: Pearson Educación.
3- M. Abellanas y D. Lodares: Análisis de Algoritmos y Teoría de Grafos.
Rama 1990
4- G. Chartrand, O. R. Oellermann Applied and algorithmic graph
5- Víctor M. Lozano Terrazas Algoritmo de Dijkstra: tutorial interactivo en
Java 2. Madrid. Facultad de Informática. U.P.M. 2000
6- LindaMay Patterson: Using the IBM XML Parser Find and replace
elements in an XML Document http://www.as400.ibm.com./
developer/java/xml/xml_parser2.html IBM XML Parser 2000.
7- P. Williams, C. MacLatchy, P. Backman y D. Retson . Studio physics
report on the Acadia: http://www.acadiau.ca/advantage/physics.htm
Department of Physics, Acadia University 1996
8- Michael A. Trick: Shortest Path http://mat.
gsia.cmu.edu/classes/networks/node4.html Carnegie Mellon University.
Computer Science Department. 1998
9- M.N.S. Swamy, K Thulasiraman: Graphs, networks, and algorithms.
New York : John Wiley & Sons, 1981
10- Steven S. Skiena: Shortest Path http://www.
cs.sunysb.edu/~algorith/files/shortestpath.shtml. Stone Brook (State
University of New York). Computer Science Department, 2001

82