Added Prim's algorithm to compute a minimum spanning tree of an undirected graph

git-svn-id: https://java-algorithms-implementation.googlecode.com/svn/trunk@67 032fbc0f-8cab-eb90-e552-f08422b9a96a

Author: phishman3579

src/com/jwetherell/algorithms/DataStructures.java

@@ -4,6 +4,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Random;
+import java.util.Set;
 
 import com.jwetherell.algorithms.data_structures.BinarySearchTree;
 import com.jwetherell.algorithms.data_structures.BinaryHeap;
@@ -17,6 +18,7 @@
 import com.jwetherell.algorithms.data_structures.Stack;
 import com.jwetherell.algorithms.graph.BellmanFord;
 import com.jwetherell.algorithms.graph.Dijkstra;
+import com.jwetherell.algorithms.graph.Prim;
 
 
 public class DataStructures {
@@ -300,6 +302,10 @@ public static void main(String[] args) {
             BellmanFord.CostPathPair pair2 = BellmanFord.getShortestPath(undirected, start, end);
             if (pair2!=null) System.out.println(pair2.toString());
             else System.out.println("No path from "+start.getValue()+" to "+end.getValue());
+
+            System.out.println("Prim's minimum spanning tree of the undirected graph from "+start.getValue());
+            Set<Graph.Edge> set = Prim.getMinimumSpanningTree(undirected, start);
+            System.out.println(set.toString());
             System.out.println();
         }
 

src/com/jwetherell/algorithms/data_structures/Graph.java

@@ -52,6 +52,10 @@ public Graph(TYPE type, List<Vertex> verticies, List<Edge> edges) {
         }
     }
 
+    public TYPE getType() {
+        return type;
+    }
+    
     public List<Vertex> getVerticies() {
         return verticies;
     }

src/com/jwetherell/algorithms/graph/Prim.java

@@ -0,0 +1,56 @@
+package com.jwetherell.algorithms.graph;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Set;
+
+import com.jwetherell.algorithms.data_structures.Graph;
+
+
+/**
+ * Prim's minimum spanning tree. Only works on undirected graphs. It finds a subset of the edges 
+ * that forms a tree that includes every vertex, where the total weight of all the edges in the tree is minimized.
+ * 
+ * @author Justin Wetherell <phishman3579@gmail.com>
+ */
+public class Prim {
+
+    private static Set<Graph.Edge> path = null;
+    private static List<Graph.Vertex> unvisited = null;
+    private static Queue<Graph.Edge> edgesAvailable = null;
+
+    private Prim() { }
+
+    public static Set<Graph.Edge> getMinimumSpanningTree(Graph g, Graph.Vertex start) {
+        if (g==null) throw (new NullPointerException("Graph must be non-NULL."));
+        
+        // Prim's algorithm only works on undirected graphs
+        if (g.getType() == Graph.TYPE.DIRECTED) throw (new IllegalArgumentException("Undirected graphs only.")); 
+
+        path = new LinkedHashSet<Graph.Edge>();
+        
+        unvisited = new ArrayList<Graph.Vertex>();
+        unvisited.addAll(g.getVerticies());
+        unvisited.remove(start);
+        
+        edgesAvailable = new PriorityQueue<Graph.Edge>();
+
+        Graph.Vertex vertex = start;
+        while (!unvisited.isEmpty()) {
+            for (Graph.Edge e : vertex.getEdges()) {
+                if (unvisited.contains(e.getToVertex())) edgesAvailable.add(e);
+            }
+
+            Graph.Edge e = edgesAvailable.remove();
+            path.add(e);
+
+            vertex = e.getToVertex();            
+            unvisited.remove(vertex);
+        }
+        
+        return path;
+    }
+}