Boas, eu tenho um projecto sobre grafos que possui um vector de vertices e cada vertice tem uma LinkedList de arcos , eu preciso de fazer um método que imprima todos os arcos do grafo, eu estava fazendo um método que percorria vertice a vertice e sacava todos os arcos para uma string, o problema é k por exemplo um arco que vai do vertice 1 para o vertice 2 , vai aparecer kuando eu sacar os arcos do vertice 1 e kuando eu sacar do vertice 2.
Alguém já fez algo parecido ? ou tem alguma ideia ?
opa beleza?
como que está o seu código atual para armazenar e
representar os seus vértices e seus arcos?
você já tentou montar algum algoritmo de percurso?
mande os códigos ae para o pessoal sugerir algumas
ideias 
abraços
Aqui vai…
Class Vertice
import java.util.*;
public class Vertex {
private String id; // id do vértice
private int index;
private LinkedList <WeightedEdge> edges; // contêm a lista de arcos q têm origem neste vértice
public Vertex(String id,int index){
edges = new LinkedList<WeightedEdge>();
this.id=id; // identificador do vértice
this.index=index; // indice onde o vértice se encontra no grafo
}
//Adiciona um novo arco a edges, com origem neste
// vértice, fim e peso passados como parâmetros
public boolean addEdge( Vertex d,int p){
WeightedEdge we = new WeightedEdge(this,d,p);
return(edges.add(we)); // como o método add é boolean vai retornar true se for adicionado
}
//retorna true se o objecto referencia um vértice, caso contrário é falso
public boolean equals(Object o) {
if (o instanceof Vertex) {
Vertex v = (Vertex) o;
if (this.id == v.id)
return true;
}
return false;
}
//Percorre a lista de arcos e retorna um iterador para os vértices
public VertexIterator getEdgesIterator(){
VertexIterator vI = new VertexIterator();
return vI;
}
// retorna o id do vértice
public String getId(){
return id;
}
//retorna o index do vértice
public int getIndex(){
return index;
}
//remove um arco da lista de arcos deste mesmo vértice
public boolean removeEdge(WeightedEdge a){
Iterator it = edges.listIterator();
while(it.hasNext()){
if(a.equals(it.next())){
it.remove();
return true;
}
}
return false;
}
//retorna o id do vértice
public String toString(){
return getId();
}
//Inner Class
//Classe VertexIterator, percorre os vértices dos arcos da lista
public class VertexIterator implements Iterator{
Iterator it = edges.listIterator();
//testa se há seguinte
public boolean hasNext() {
return (it.hasNext());
}
//retorna o próximo elemento
public Vertex next() {
WeightedEdge we = (WeightedEdge)it.next();
return we.getEnd();
}
//remove um arco
public void remove() {
it.remove();
}
}
private WeightedEdge [] vEdges;
public Vector<WeightedEdge> vertexGetEdge(){
Vector <WeightedEdge>vEdges = new Vector <WeightedEdge>();
Iterator it = edges.listIterator();
WeightedEdge we=null;
while(it.hasNext()){
we= (WeightedEdge) it.next();
vEdges.add(we);
}
return vEdges;
}
}
Class Arco
public class WeightedEdge {
private int weight; //peso do arco
private Vertex init, end; //vértice de inicio e fim do arco
//cria um arco com inicio em vo, fim em vd e peso p
public WeightedEdge(Vertex vo, Vertex vd, int p){
this.init = vo;
this.end = vd;
this.weight = p;
}
// retorna true se o objecto ref arco igual,false caso contrário
//2 arcos são iguais se ligarem os mesmos vértices
public boolean equals(Object o) {
if (o instanceof WeightedEdge) {
WeightedEdge we = (WeightedEdge) o;
if ((this.init == we.init) && (this.end == we.end))
return true;
}
return false;
}
//retorna o vértice de destino do arco
public Vertex getEnd(){
return (this.end);
}
//retorna o vértice de origem do arco
public Vertex getInit(){
return (this.init);
}
//retorna o peso do arco
public int getWeight(){
return weight;
}
//exibe o arco e os seus parâmetros
public String toString(){
return "("+this.init+","+ this.end + ","+ this.weight +")";
}
}Class Grafo
import java.util.Vector;
public class Graph {
private Vector<Vertex> vertices; // contém os vértices do grafo
// construtor do grafo
public Graph() {
vertices = new Vector<Vertex>();
}
/*
* adiciona um arco ao vertice do grafo com id = id1, um arco que termina no
* vértice com id=id2 e peso w
*/
public boolean addEdge(String id1, String id2, int w) {
Vertex v1 = this.get(id1);
Vertex v2 = this.get(id2);
if (v1.addEdge(v2, w)&& v2.addEdge(v1, w))
return true;
return false;
}
/*
* retorna o vértice do grafo com id igual ao recebido como parametro ou
* null caso não exista
*/
public Vertex get(String id) {
for (int i = 0; i < vertices.size(); ++i) {
if (vertices.elementAt(i).getId().equals(id)) {
return vertices.get(i);
}
}
return null;
}
/* retorna o vértice do gráfico com index igual ao passado
* por parametro ou null caso não exista */
public Vertex get(int v) {
for (int i = 0; i < vertices.size(); ++i) {
if (vertices.elementAt(i).getIndex() == v) {
return vertices.get(i);
}
}
return null;
}
//retorna os ids dos vértices
public String idsVertices() {
String id="";
String aux="";
for (int i = 0; i < vertices.size(); ++i) {
aux = vertices.elementAt(i).getId();
id+=" "+ aux;
}
return id;
}
//retorna o número de vertices
public int getSize() {
return vertices.size();
}
// public boolean removeEdge(WeightedEdge e){
// return true; //mudar
// }
// public String toString() {
// String aux="";
// String st="";
// for (int i = 0; i < vertices.size(); ++i) {
// Vertex v = vertices.elementAt(i);
// aux = v.vertexToEdge();
// st+=aux;
// }
// return "["+st+ "]";
// }
/*
* retorna o vértice do grafo com id igual ao recebido como parametro, caso
* não exista um vertice com este id adiciona ao grafo um novo vértice com
* este id e index igual à posição em que foi adicionado
*/
public Vertex vertex(String id) {
for (int i = 0; i < vertices.size(); ++i) {
if (vertices.elementAt(i).getId().equals(id)) {
return vertices.get(i);
}
}
Vertex ver = new Vertex(id, vertices.size());
vertices.add(ver);
return ver;
}
}