data_structures_free

2014-03-24 18:47:50 +01:00
commit 6f92828c96
65 changed files with 4738 additions and 0 deletions
--- a/net/datastructures/Dijkstra.java
+++ b/net/datastructures/Dijkstra.java
@@ -0,0 +1,97 @@
+package net.datastructures;
+import java.util.Iterator;
+import java.lang.reflect.Field;
+
+/** 
+ * Dijkstra's algorithm for the single-source shortest path problem in
+ * an undirected graph whose edges have integer weights.  
+ *
+ * <p>To execute the algorithm, use the {@link
+ * #execute(Graph,Vertex,Object) execute} method, and then make
+ * subsequent calls to the {@link #getDist(Vertex) getDist} method to
+ * obtain the shortest distance from the start to any given vertex.
+ *
+ * @author Roberto Tamassia, Michael Goodrich, Eric Zamore
+ */
+
+//begin#fragment execute
+/* Dijkstra's algorithm for the single-source shortest path problem
+ * in an undirected graph whose edges have non-negative integer weights.  */
+public class Dijkstra<V, E> {
+  /** Infinity value. */
+  protected static final Integer INFINITE = Integer.MAX_VALUE;
+  /** Input graph. */
+  protected Graph<V, E> graph;
+  /** Decoration key for edge weights */
+  protected Object WEIGHT;
+  /** Decoration key for vertex distances  */
+  protected Object DIST = new Object();
+  /** Decoration key for entries in the priority queue */
+  protected Object ENTRY = new Object();
+  /** Auxiliary priority queue. */
+  protected AdaptablePriorityQueue<Integer, Vertex<V>> Q;
+  /** Executes Dijkstra's algorithm.
+    * @param g Input graph
+    * @param s Source vertex
+    * @param w Weight decoration object */
+  public void execute(Graph<V, E> g, Vertex<V> s, Object w) {
+    graph = g;
+    WEIGHT = w;
+    DefaultComparator dc = new DefaultComparator();
+    Q = new HeapAdaptablePriorityQueue<Integer, Vertex<V>>(dc);
+    dijkstraVisit(s);
+  }
+  /** Get the distance of a vertex from the source vertex.
+//end#fragment execute
+   * This method returns the length of a shortest path from the source
+   * to <tt>u</tt> after {@link #execute(Graph,Vertex,Object) execute}
+   * has been called.
+//begin#fragment execute
+   * @param u Start vertex for the shortest path tree */
+  public int getDist(Vertex<V> u) {
+    return (Integer) u.get(DIST);
+  }
+//end#fragment execute
+
+  //begin#fragment dijkstraVisit
+  /** The actual execution of Dijkstra's algorithm.
+    * @param v source vertex.  
+    */
+  protected void dijkstraVisit (Vertex<V> v) {
+    // store all the vertices in priority queue Q
+    for (Vertex<V> u: graph.vertices()) {
+      int u_dist;
+      if (u==v)
+	u_dist = 0;
+      else
+	u_dist = INFINITE;
+      Entry<Integer, Vertex<V>> u_entry = Q.insert(u_dist, u);	// autoboxing
+      u.put(ENTRY, u_entry);
+    }
+    // grow the cloud, one vertex at a time
+    while (!Q.isEmpty()) {
+      // remove from Q and insert into cloud a vertex with minimum distance
+      Entry<Integer, Vertex<V>> u_entry = Q.min();
+      Vertex<V> u = u_entry.getValue();
+      int u_dist = u_entry.getKey();
+      Q.remove(u_entry); // remove u from the priority queue
+      u.put(DIST,u_dist); // the distance of u is final
+      u.remove(ENTRY); // remove the entry decoration of u
+      if (u_dist == INFINITE)
+	continue; // unreachable vertices are not processed
+      // examine all the neighbors of u and update their distances
+      for (Edge<E> e: graph.incidentEdges(u)) {
+	Vertex<V> z = graph.opposite(u,e);
+	Entry<Integer, Vertex<V>> z_entry 
+	                          = (Entry<Integer, Vertex<V>>) z.get(ENTRY);
+	if (z_entry != null) { // check that z is in Q, i.e., not in the cloud
+	  int e_weight = (Integer) e.get(WEIGHT);
+	  int z_dist = z_entry.getKey();
+	  if ( u_dist + e_weight < z_dist ) // relaxation of edge e = (u,z)
+	    Q.replaceKey(z_entry, u_dist + e_weight);
+	}
+      }
+    }
+  }
+  //end#fragment dijkstraVisit
+} // end of Dijkstra class