v1.0.6

Author: RyanAlbertson

.idea/workspace.xml

@@ -87,6 +87,7 @@ The application is launched by executing _Algorithm.Visualizer.exe_
   - Depth-First Search
   - Breadth-First Search
   - Dijkstra's Algorithm
+  - A* Search
   - Reverse Delete
   - Kruskal's Algorithm
   - Prim's Algorithm
@@ -111,6 +112,9 @@ The application is launched by executing _Algorithm.Visualizer.exe_
 > Instant Dijkstra's algorithm on large graphs
 > <img src="./media/dijkstra2.gif" width=800>
 
+> Slow A* Search algorithm on a large graph
+> <img src="./media/a_star.gif" width=800>
+
 > Fast Kruskal's algorithm on a large graph
 > <img src="./media/kruskal.gif" width=800>
 

Algorithm Visualizer.exe

@@ -46,8 +46,8 @@ public MOUSE_STATE next() {
     private MOUSE_STATE mouseState;
     protected Algorithm algorithm;
     protected String graphSize;
-    protected HashMap<Integer, Integer[]> nodeCoords;
     protected HashMap<Integer, Shape> nodeShapes;
+    public HashMap<Integer, Integer[]> nodeCoords;
     public String algName;
     public boolean isShortPathAlg;
     public DefaultUndirectedWeightedGraph<Integer, DefaultWeightedEdge> graph;
@@ -247,6 +247,9 @@ protected void startAlgorithm() {
                 case "Dijkstra":
                     algorithm = new Dijkstra(this);
                     break;
+                case "A*":
+                    algorithm = new A_Star(this);
+                    break;
                 case "Reverse Delete":
                     algorithm = new ReverseDelete(this);
                     break;

README.md

@@ -11,14 +11,16 @@ public class Defs {
 
     // All algorithms available with the visualizer
     public static final List<String> algNames = List.of("Depth-First Search",
-            "Breadth-First Search", "Dijkstra", "Reverse Delete", "Kruskal", "Prim");
+            "Breadth-First Search", "Dijkstra", "A*",
+            "Reverse Delete", "Kruskal", "Prim");
 
     // Maps algorithms to whether they should use minimum connected graphs or not.
     public static final Map<String, Boolean> isShortPathAlg =
             Collections.unmodifiableMap(Map.ofEntries(
                     Map.entry("Depth-First Search", true),
                     Map.entry("Breadth-First Search", true),
                     Map.entry("Dijkstra", true),
+                    Map.entry("A*", true),
                     Map.entry("Reverse Delete", false),
                     Map.entry("Kruskal", false),
                     Map.entry("Prim", false)));

media/a_star.gif

@@ -0,0 +1,110 @@
+package main.java.util.algorithms;
+
+
+import main.java.GraphPanel;
+import org.jgrapht.graph.DefaultWeightedEdge;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.PriorityQueue;
+
+/**
+ * Implements an A* search algorithm to find a shortest path from a
+ * {@link GraphPanel#sourceNode} to a {@link  GraphPanel#targetNode}.
+ *
+ * @author Ryan Albertson
+ */
+public class A_Star extends Algorithm {
+
+
+    /**
+     * Constructor.
+     * @param gPanel {@link GraphPanel}.
+     */
+    public A_Star(GraphPanel gPanel) {
+
+        super(gPanel);
+    }
+
+
+    public void runAlgorithm(Integer node) {
+
+        // Init distance to reach each node through the search
+        double[] distanceTo = new double[gPanel.nodeCount];
+        Arrays.fill(distanceTo, Double.POSITIVE_INFINITY);
+        distanceTo[node] = 0.0;
+
+        // Init estimated remaining distance to target node from each node
+        double[] distanceAfter = new double[gPanel.nodeCount];
+        double targetX = gPanel.nodeCoords.get(gPanel.targetNode)[0];
+        double targetY = gPanel.nodeCoords.get(gPanel.targetNode)[1];
+        for (int i = 0; i < gPanel.nodeCount; i++) {
+            double iX = gPanel.nodeCoords.get(i)[0];
+            double iY = gPanel.nodeCoords.get(i)[1];
+            double dist = Math.sqrt(Math.pow(Math.abs(iY - targetY), 2) +
+                    Math.pow(Math.abs(iX - targetX), 2));
+            distanceAfter[i] = dist;
+        }
+
+        // Node priority considers the sum: distance[i] + distanceAfter[i]
+        Double[] prio = new Double[gPanel.nodeCount];
+        for (int i = 0; i < gPanel.nodeCount; i++) prio[i] = Double.MAX_VALUE;
+
+        boolean[] isExplored = new boolean[gPanel.nodeCount];
+
+        // Order of nodes to be visited
+        PriorityQueue<Integer> nodesQueue = new PriorityQueue<>((node1, node2) ->
+                prio[node1].compareTo(prio[node2]));
+        nodesQueue.add(node);
+
+        // Store nodes & edges from previous iterations of loop. For animation purposes
+        Map<Integer, Integer> prevNode = new HashMap<>();
+        Map<Integer, DefaultWeightedEdge> edgeTo = new HashMap<>();
+
+        while (!nodesQueue.isEmpty()) {
+            Integer currentNode = nodesQueue.poll();
+            isExplored[currentNode] = true;
+            DefaultWeightedEdge edgeToCurrentNode = edgeTo.get(currentNode);
+            if (null != edgeToCurrentNode) gPanel.visitedEdges.add(edgeToCurrentNode);
+            Integer prev = prevNode.get(currentNode);
+            if (null != prev) gPanel.path[currentNode] = prev;
+
+            for (DefaultWeightedEdge edgeToAdjNode : gPanel.graph.edgesOf(currentNode)) {
+                if (gPanel.visitedEdges.contains(edgeToAdjNode)) continue;
+                Integer adjNode = gPanel.graph.getEdgeTarget(edgeToAdjNode);
+                // Account for directed edges
+                if (adjNode.equals(currentNode)) {
+                    adjNode = gPanel.graph.getEdgeSource(edgeToAdjNode);
+                }
+                if (isExplored[adjNode]) continue;
+                // Update adjNode's distance if this path is shorter than current
+                double currentDist = distanceTo[adjNode];
+                double newDist = distanceTo[currentNode] +
+                        gPanel.graph.getEdgeWeight(edgeToAdjNode);
+                if (newDist < currentDist) {
+                    distanceTo[adjNode] = newDist;
+                }
+                // Update total distance if this estimated path is shorter
+                double totalDist = distanceTo[adjNode] + distanceAfter[adjNode];
+                if (totalDist < prio[adjNode]) {
+                    prio[adjNode] = totalDist;
+                    nodesQueue.add(adjNode);
+                    prevNode.put(adjNode, currentNode);
+                    edgeTo.put(adjNode, edgeToAdjNode);
+                }
+            }
+            // Check if user has stopped or paused algorithm
+            animate();
+            if (isStopped()) return;
+            // Stop algorithm if a path to the target has been found
+            if (currentNode.equals(gPanel.targetNode)) break;
+        }
+    }
+
+
+    public void runAlgorithm() {
+
+        // This signature isn't needed for this algorithm.
+    }
+}