Java Graph.getEdges方法代码示例

import edu.uci.ics.jung.graph.Graph; //导入方法依赖的package包/类
/**
 * This method reverse the path "path" in the graph "graph" and returns it.
 * 
 * @param graph
 *            the input graph which will not be changed.
 * @param path
 *            the path to reverse
 * @return a new graph with the reversed path
 */
private Graph<V, E> reverseEdges(Graph<V, E> graph, List<E> path) {
	if (graph == null || path == null)
		throw new IllegalArgumentException();
	Graph<V, E> clone = new DirectedOrderedSparseMultigraph<V, E>();

	for (V v : graph.getVertices())
		clone.addVertex(v);
	for (E e : graph.getEdges())
		clone.addEdge(e, graph.getEndpoints(e));

	for (E link : path) {
		V src = clone.getSource(link);
		V dst = clone.getDest(link);
		clone.removeEdge(link);
		clone.addEdge(link, dst, src, EdgeType.DIRECTED);
	}
	return clone;
}
 

import edu.uci.ics.jung.graph.Graph; //导入方法依赖的package包/类
/**
 * Creates a minimum spanning forest from the supplied graph, populating the
 * supplied Forest, which must be empty. 
 * If the supplied root is null, or not present in the Graph,
 * then an arbitrary Graph vertex will be selected as the root.
 * If the Minimum Spanning Tree does not include all vertices of the
 * Graph, then a leftover vertex is selected as a root, and another
 * tree is created
 * @param graph the Graph to find MST in
 * @param forest the Forest to populate. Must be empty
 * @param root first Tree root, may be null
 */
public MinimumSpanningForest(Graph<V, E> graph, Forest<V,E> forest, 
        Collection<V> roots) {
    
    if(forest.getVertexCount() != 0) {
        throw new IllegalArgumentException("Supplied Forest must be empty");
    }
    this.graph = graph;
    this.forest = forest;
    Set<E> unfinishedEdges = new HashSet<E>(graph.getEdges());
    if(roots != null && !roots.isEmpty()) {
    	V root = roots.iterator().next();
    	System.out.println(root);
    	roots.remove(root);
    	this.forest.addVertex(root);
    }
    updateForest(forest.getVertices(), unfinishedEdges, roots);
}
 

import edu.uci.ics.jung.graph.Graph; //导入方法依赖的package包/类
/**
 * This method does the following length transformation:
 * 
 * <pre>
 *  c'(v,w) = c(v,w) - d (s,w) + d (s,v)
 * </pre>
 * 
 * @param graph1
 *            the graph
 * @param slTrans
 *            The shortest length transformer
 * @return the transformed graph
 */
private Transformer<E, Double> lengthTransformation(Graph<V, E> graph1,
		Transformer<V, Number> slTrans) {
	Map<E, Double> map = new HashMap<E, Double>();

	for (E link : graph1.getEdges()) {
		double newWeight = nev.transform(link).doubleValue()
				- slTrans.transform(graph1.getDest(link)).doubleValue()
				+ slTrans.transform(graph1.getSource(link)).doubleValue();

		map.put(link, newWeight);
	}
	return MapTransformer.getInstance(map);
}
 

import edu.uci.ics.jung.graph.Graph; //导入方法依赖的package包/类
public static void graphToDot(Graph<Vertex,Edge> graph, PrintStream ps){
	
	  ps.println("digraph g {");
         ps.println("node [style=filled, color=black, fillcolor=gray, shape=circle, label=\"\", height=.15, width=.15]");
         
         for (Vertex vertex : graph.getVertices()) {
       	  ps.println(vertex.toString() + "[label=\"" + vertex.getLabel() + "\"]");
         }
         for (Edge edge :graph.getEdges()) {
       	  ps.println( graph.getSource(edge)+ "->" + graph.getDest(edge).toString());
         }
         ps.println("}");
}
 

import edu.uci.ics.jung.graph.Graph; //导入方法依赖的package包/类
/**
 * used by a test method to validate the weights of the edges by a
 * one-to-one comparison. An Edge implements a comparator based only on the
 * edge weight.
 * 
 * @param expected
 *            The original (expected) network, before exporting it
 * @param actual
 *            The actual (imported) network to be compared with the expected
 */
private void validateEdgeWeights(Graph<Vertex, Edge> expected,
		Graph<Vertex, Edge> actual) {
	List<Edge> expEdges = new ArrayList<Edge>(expected.getEdges());
	List<Edge> actEdges = new ArrayList<Edge>(actual.getEdges());

	Collections.sort(expEdges);
	Collections.sort(actEdges);
	Assert.assertEquals(expEdges, actEdges);
}