Removed node class, works with any class

Author: tdebatty

src/main/java/info/debatty/java/graphs/Dijkstra.java

@@ -36,13 +36,13 @@
  *
  * @author Thibault Debatty
  */
-public class Dijkstra {
+public class Dijkstra<T> {
 
     private final Graph graph;
-    private final Set<NodeInterface> settled_nodes;
-    private final Set<NodeInterface> unsettled_nodes;
-    private final Map<NodeInterface, NodeInterface> predecessors;
-    private final Map<NodeInterface, Integer> distances;
+    private final Set<T> settled_nodes;
+    private final Set<T> unsettled_nodes;
+    private final Map<T, T> predecessors;
+    private final Map<T, Integer> distances;
 
     /**
      * Compute the shortest path from source node to every other node in the
@@ -51,20 +51,20 @@ public class Dijkstra {
      * @param graph to use for computing path
      * @param source node from which to compute distance to every other node
      */
-    public Dijkstra(final Graph graph, final NodeInterface source) {
+    public Dijkstra(final Graph graph, final T source) {
 
         this.graph = graph;
 
-        settled_nodes = new HashSet<NodeInterface>();
-        unsettled_nodes = new HashSet<NodeInterface>();
-        distances = new HashMap<NodeInterface, Integer>();
-        predecessors = new HashMap<NodeInterface, NodeInterface>();
+        settled_nodes = new HashSet<T>();
+        unsettled_nodes = new HashSet<T>();
+        distances = new HashMap<T, Integer>();
+        predecessors = new HashMap<T, T>();
 
         distances.put(source, 0);
         unsettled_nodes.add(source);
 
         while (unsettled_nodes.size() > 0) {
-            NodeInterface node = getMinimum(unsettled_nodes);
+            T node = getMinimum(unsettled_nodes);
             settled_nodes.add(node);
             unsettled_nodes.remove(node);
             findMinimalDistances(node);
@@ -78,9 +78,9 @@ public Dijkstra(final Graph graph, final NodeInterface source) {
      * @return the path from the source to the selected target
      * @throws java.lang.Exception if no path exists to this target
      */
-    public final LinkedList<NodeInterface> getPath(final NodeInterface target) throws Exception {
-        LinkedList<NodeInterface> path = new LinkedList<NodeInterface>();
-        NodeInterface step = target;
+    public final LinkedList<T> getPath(final T target) throws Exception {
+        LinkedList<T> path = new LinkedList<T>();
+        T step = target;
         // check if a path exists
         if (predecessors.get(step) == null) {
             throw new Exception("No path found to this target");
@@ -112,13 +112,13 @@ public final int getLargestDistance() {
         return largest;
     }
 
-    private void findMinimalDistances(final NodeInterface node) {
-        if (!graph.containsKey(node) || graph.get(node) == null) {
+    private void findMinimalDistances(final T node) {
+        if (!graph.containsKey(node) || graph.getNeighbors(node) == null) {
             return;
         }
 
-        for (Neighbor neighbor : graph.get(node)) {
-            NodeInterface target = neighbor.node;
+        for (Neighbor<T> neighbor : graph.getNeighbors(node)) {
+            T target = neighbor.node;
 
             if (getShortestDistance(target) > (getShortestDistance(node) + 1)) {
                 distances.put(target, getShortestDistance(node) + 1);
@@ -128,9 +128,9 @@ private void findMinimalDistances(final NodeInterface node) {
         }
     }
 
-    private NodeInterface getMinimum(final Set<NodeInterface> nodes) {
-        NodeInterface minimum = null;
-        for (NodeInterface node : nodes) {
+    private T getMinimum(final Set<T> nodes) {
+        T minimum = null;
+        for (T node : nodes) {
             if (minimum == null) {
                 minimum = node;
             } else {
@@ -142,7 +142,7 @@ private NodeInterface getMinimum(final Set<NodeInterface> nodes) {
         return minimum;
     }
 
-    private int getShortestDistance(final NodeInterface destination) {
+    private int getShortestDistance(final T destination) {
         Integer d = distances.get(destination);
         if (d == null) {
             return Integer.MAX_VALUE;

src/main/java/info/debatty/java/graphs/Edge.java

@@ -5,10 +5,10 @@
  *
  * @author Thibault Debatty
  */
-public class Edge {
+public class Edge<T> {
 
-    public NodeInterface n1;
-    public NodeInterface n2;
+    public T n1;
+    public T n2;
     public double weight = 0;
 
     public static final String SEPARATOR = ";";
@@ -17,15 +17,15 @@ public Edge() {
 
     }
 
-    public Edge(NodeInterface n1, NodeInterface n2, double weight) {
+    public Edge(T n1, T n2, double weight) {
         this.n1 = n1;
         this.n2 = n2;
         this.weight = weight;
     }
 
     @Override
     public String toString() {
-        return n1.getId() + SEPARATOR + n2.getId() + SEPARATOR + weight;
+        return n1.toString() + SEPARATOR + n2.toString()+ SEPARATOR + weight;
 
     }
 }