Diferencia entre revisiones de «Programación en Java/Apéndices/Implementación del Algoritmo de Kruskal en Java»
Contenido eliminado Contenido añadido
m Revertidos los cambios de 181.128.244.138 (disc.) a la última edición de Matiia |
|||
Línea 52:
===Estructura Grafo===
====Clase Enlace====
La clase enlace se utiliza para hacer refencia al nodo terminal y al peso de un arco.
Línea 239:
}
}
</source>
====Clase Grafo====
Representa la estructura grafo, compuesta por nodos y arcos.
<source lang="java">
import java.util.Hashtable;
import java.util.ArrayList;
public class Grafo
{
ArrayList <String>nombres;
ArrayList <Arco>aristas;
Hashtable <String,Nodo> nodos;
public Grafo()
{
nombres=new ArrayList<String>();
nodos=new Hashtable <String,Nodo>();
aristas=new ArrayList <Arco>();
}
public void ingresarNodo(String nombre)
{
nombres.add(nombre);
nodos.put(nombre,new Nodo(nombre));
}
public void adicionarEnlace(String nodoInicial,String nodoTerminal,float peso)
{
Arco nuevo=new Arco(nodoInicial,nodoTerminal,peso);
int i=buscarIndice(nuevo.getPeso());
if(i==-1)
aristas.add(nuevo);
else
aristas.add(i,nuevo);
nodos.get(nodoInicial).agregarEnlace(nodoTerminal,peso);
nodos.get(nodoTerminal).agregarEnlace(nodoInicial,peso);
}
public boolean busarArista(Arco arco)
{
for(int i=0;i<aristas.size();i++)
{
Arco otro=aristas.get(i);
if(arco.getInicial().equals(otro.getInicial())&&arco.getTerminal().equals(otro.getTerminal())&&arco.getPeso()==otro.getPeso())
{
aristas.remove(otro);
return true;
}
}
return false;
}
public int buscarIndice(float peso)
{
for(int i=0;i<aristas.size();i++)
{
if(peso<aristas.get(i).getPeso())
return i;
}
return -1;
}
public Hashtable getNodos()
{
return nodos;
}
public void setNodos(Hashtable<String,Nodo > muchos)
{
nodos=muchos;
}
public ArrayList<String> getNombres()
{
return nombres;
}
public Nodo getNodo(String nombre)
{
return (Nodo)nodos.get(nombre);
}
public ArrayList<Arco> getAristas() {
return aristas;
}
public void setAristas(ArrayList<Arco> aristas) {
this.aristas = aristas;
}
public void setNombres(ArrayList<String> nombres) {
this.nombres = nombres;
}
}
</source>
===Interfaz Gráfica===
====Clase Lienzo====
Es el lienzo sobre el cual se dibujará el grafo.
<source lang="java">
import java.awt.*;
import java.util.ArrayList;
import javax.swing.JComponent;
public class Lienzo extends JComponent
{
private ArrayList<Punto> puntos;
private ArrayList<Arista> aristas;
private ArrayList<Arista> neo;
private Point a, b;
public boolean estado = false;
public boolean punto = false;
public Lienzo()
{
aristas = new ArrayList<Arista>();
puntos = new ArrayList<Punto>();
neo = new ArrayList<Arista>();
}
public void paintComponent(Graphics g)
{
if (punto)
{
g.setColor(Color.BLUE);
g.drawLine((int) a.getX() + 5, (int) a.getY() + 5, (int) b.getX() + 5, (int) b.getY() + 5);
}
for (int i = 0; i < aristas.size(); i++)
{
final Arista arista = (Arista) aristas.get(i);
arista.pintarRecta(g);
}
if (estado)
for (int i = 0; i < neo.size(); i++)
{
final Arista arista = (Arista) neo.get(i);
arista.setColor(Color.RED);
arista.pintarRecta(g);
}
for (int i = 0; i < puntos.size(); i++)
{
final Punto punto = (Punto) puntos.get(i);
punto.pintarPunto(g);
}
}
public void cambiarGrafo(Grafo nuevo)
{
Arco aux;
for (int i = 0; i < aristas.size(); i++)
{
aux = aristas.get(i).getArista();
if (nuevo.busarArista(aux) == true)
neo.add(aristas.get(i));
}
for (int i = 0; i < aristas.size(); i++)
{
final Arco n = aristas.get(i).getArista();
nuevo.getAristas().add(n);
}
estado = true;
repaint();
}
public ArrayList<Punto> getPuntos()
{
return puntos;
}
public void setPuntos(final ArrayList<Punto> puntos)
{
this.puntos = puntos;
}
public ArrayList<Arista> getAristas()
{
return aristas;
}
public void setAristas(final ArrayList<Arista> aristas)
{
this.aristas = aristas;
}
public ArrayList<Arista> getNeo()
{
return neo;
}
public void setNeo(final ArrayList<Arista> neo)
{
this.neo = neo;
}
public void setA(Point a)
{
this.a = a;
}
public void setB(Point b)
{
this.b = b;
}
}
</source>
====Clase Punto====
Permite dibujar un punto sobre el lienzo. Hace referencia a la posición del punto sobre el lienzo.
<source lang="java">
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
public class Punto
{
private Point ubicacion;
private String nombre;
private Color colorPunto = Color.BLUE;
private static final int RADIO = 10;
public Punto(int x, int y, String nombre)
{
ubicacion = new Point(x, y);
this.nombre = nombre;
}
public void pintarPunto(Graphics g)
{
g.setColor(Color.BLACK);
g.drawString(nombre, ubicacion.x - 3, ubicacion.y - 3);
g.setColor(colorPunto);
g.fillOval(ubicacion.x, ubicacion.y, 10, 10);
}
public void pintarPunto(Graphics g, Color color)
{
g.setColor(Color.BLACK);
g.drawString(nombre, ubicacion.x - 3, ubicacion.y - 3);
g.setColor(color);
g.fillOval(ubicacion.x, ubicacion.y, 10, 10);
}
public boolean ecuacionDeCirculo(Point punto)
{
return (((punto.x - ubicacion.x) * (punto.x - ubicacion.x) + (punto.y - ubicacion.y) * (punto.y - ubicacion.y)) <= (RADIO * RADIO));
}
public Point getUbicacion()
{
return ubicacion;
}
public String getNombre()
{
return nombre;
}
public void setUbicacion(Point ubicacion)
{
this.ubicacion = ubicacion;
}
public Color getColorPunto()
{
return colorPunto;
}
public void setColorPunto(Color colorPunto)
{
this.colorPunto = colorPunto;
}
}
</source>
====Clase Arista====
Permite dibujar una arista entre dos puntos sobre el lienzo. Hace referencia a los puntos.
<source lang="java">
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.geom.QuadCurve2D;
public class Arista
{
private Arco arista;
private Punto a, b;
private Point inicial;
private Point terminal, ubicacionExt;
private Color color = new Color(0, 128, 128), aux = Color.RED;
private int tipo;
private float peso;
public Arista(Punto puntoA, Punto puntoB, int tipo, float peso)
{
arista = new Arco(puntoA.getNombre(), puntoB.getNombre(), peso);
a = puntoA;
b = puntoB;
this.tipo = tipo;
this.peso = peso;
}
public void pintarRecta(Graphics ga)
{
inicial = a.getUbicacion();
terminal = b.getUbicacion();
Graphics2D g = (Graphics2D) ga;
double a = (inicial.y - terminal.y);
double b = (inicial.x - terminal.x);
double m = a / b;
double grado = Math.atan(m);
switch (tipo)
{
case 0:
g.setColor(color);
g.drawLine(inicial.x + 5, inicial.y + 5, terminal.x + 5, terminal.y + 5);
g.setColor(aux);
g.drawString(peso + "", (inicial.x + terminal.x) / 2, (inicial.y + terminal.y) / 2);
break;
case 1:
g.setColor(color);
g.drawOval(inicial.x - 10, inicial.y - 30, 30, 30);
g.setColor(aux);
g.drawString(peso + "", inicial.x - 3, inicial.y - 30);
break;
case 2:
Point control = null;
if (grado > 0)
{
if (grado <= 45 && grado >= 0)
control = new Point((inicial.x + terminal.x) / 2 - 10, (inicial.y + terminal.y) / 2 + 50);
if (grado <= 90 && grado > 45)
control = new Point((inicial.x + terminal.x) / 2 + 50, (inicial.y + terminal.y) / 2 + 10);
}
else
{
if (grado >= -45 && grado <= 0)
control = new Point((inicial.x + terminal.x) / 2 - 30, (inicial.y + terminal.y) / 2 - 10);
if (grado >= -90 && grado < -45)
control = new Point((inicial.x + terminal.x) / 2 - 50, (inicial.y + terminal.y) / 2 - 10);
}
Point tempInicial = new Point(inicial.x + 5, inicial.y + 5),
tempFinal = new Point(terminal.x + 5, terminal.y + 5);
QuadCurve2D.Double quad = new QuadCurve2D.Double();
quad.setCurve(tempInicial, control, tempFinal);
g.setColor(aux);
g.drawString(peso + "", control.x, control.y);
g.setColor(color);
g.draw(quad);
break;
}
}
public Point getUbicacion()
{
return ubicacionExt;
}
public int getTipo()
{
return tipo;
}
public Arco getArista()
{
return arista;
}
public void setArista(Arco arista)
{
this.arista = arista;
}
public void getColor()
{
color = new Color(0, 128, 128);
aux = Color.RED;
}
public void setColor(Color color)
{
if (color.equals(new Color(0, 128, 128)))
aux = Color.RED;
else
aux = Color.BLUE;
this.color = color;
}
}
</source>
| |||