Update AStarSearch.java

Author: bhoomika1714

src/main/java/com/thealgorithms/graph/AStarSearch.java

@@ -1,13 +1,14 @@
 package com.thealgorithms.graph;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.PriorityQueue;
 import java.util.Set;
-import java.util.HashSet;
-import java.util.Collections;
+import java.util.Scanner;
 
 /**
  * Implementation of the A* Search Algorithm for shortest pathfinding.
@@ -23,70 +24,17 @@
  *
  * <p>
  * Time Complexity: O(E + V log V) with a binary heap priority queue.<br>
- * Space Complexity: O(V + E).
- * </p>
- *
- * <p>
- * Usage is intended programmatically via the {@link Graph} and {@link #findPath}
- * method; interactive input should be handled externally or via tests.
+ * Space Complexity: O(V + E)
  * </p>
  */
 public class AStarSearch {
 
-    /**
-     * Represents a weighted directed graph using adjacency lists.
-     */
-    public static class Graph {
-        private final Map<Integer, List<int[]>> adjacencyList;
-
-        /**
-         * Constructs an empty graph.
-         */
-        public Graph() {
-            adjacencyList = new HashMap<>();
-        }
-
-        /**
-         * Adds an undirected edge between nodes {@code u} and {@code v} with a weight.
-         *
-         * @param u      first node
-         * @param v      second node
-         * @param weight weight of the edge
-         */
-        public void addEdge(int u, int v, int weight) {
-            adjacencyList.computeIfAbsent(u, k -> new ArrayList<>()).add(new int[] { v, weight });
-            adjacencyList.computeIfAbsent(v, k -> new ArrayList<>()).add(new int[] { u, weight });
-        }
-
-        /**
-         * Returns the adjacency list for a node.
-         *
-         * @param node node index
-         * @return list of int[] {neighbor, weight}
-         */
-        public List<int[]> getEdges(int node) {
-            return adjacencyList.getOrDefault(node, Collections.emptyList());
-        }
-
-        /**
-         * Returns all nodes in the graph.
-         *
-         * @return set of node indices
-         */
-        public Set<Integer> getNodes() {
-            return adjacencyList.keySet();
-        }
-    }
-
-    /**
-     * Node used in the priority queue for A*.
-     */
     private static class Node implements Comparable<Node> {
-        final int id;
-        final double g; // cost from start
-        final double h; // heuristic
-        final double f; // total = g + h
-        final Node parent;
+        int id;
+        double g; // cost from start
+        double h; // heuristic to goal
+        double f; // total cost = g + h
+        Node parent;
 
         Node(int id, double g, double h, Node parent) {
             this.id = id;
@@ -97,28 +45,47 @@ private static class Node implements Comparable<Node> {
         }
 
         @Override
-        public int compareTo(Node o) {
-            return Double.compare(this.f, o.f);
+        public int compareTo(Node other) {
+            return Double.compare(this.f, other.f);
         }
     }
 
-    private final Graph graph;
+    private final Map<Integer, List<int[]>> graph;
+
+    /** Constructs an empty graph. */
+    public AStarSearch() {
+        graph = new HashMap<>();
+    }
+
+    /**
+     * Adds an undirected edge between nodes u and v with the given weight.
+     *
+     * @param u first node
+     * @param v second node
+     * @param weight edge weight
+     */
+    public void addEdge(int u, int v, int weight) {
+        graph.computeIfAbsent(u, k -> new ArrayList<>()).add(new int[]{v, weight});
+        graph.computeIfAbsent(v, k -> new ArrayList<>()).add(new int[]{u, weight});
+    }
 
     /**
-     * Constructs an A* solver for a given graph.
+     * Heuristic function for A* (simplified as absolute difference).
      *
-     * @param graph weighted graph
+     * @param node current node
+     * @param goal goal node
+     * @return heuristic estimate
      */
-    public AStarSearch(Graph graph) {
-        this.graph = graph;
+    private double heuristic(int node, int goal) {
+        return Math.abs(goal - node);
     }
 
     /**
-     * Finds the shortest path from {@code start} to {@code goal} using A* search.
+     * Finds the shortest path from start to goal using A* algorithm.
      *
-     * @param start starting node
-     * @param goal  goal node
-     * @return list of nodes representing the shortest path, empty if none
+     * @param start start node
+     * @param goal goal node
+     * @return list of nodes representing the shortest path
      */
     public List<Integer> findPath(int start, int goal) {
         PriorityQueue<Node> openSet = new PriorityQueue<>();
@@ -130,45 +97,32 @@ public List<Integer> findPath(int start, int goal) {
 
         while (!openSet.isEmpty()) {
             Node current = openSet.poll();
-
             if (current.id == goal) {
                 return reconstructPath(current);
             }
 
             closedSet.add(current.id);
-
-            for (int[] edge : graph.getEdges(current.id)) {
+            for (int[] edge : graph.getOrDefault(current.id, new ArrayList<>())) {
                 int neighbor = edge[0];
                 double tentativeG = current.g + edge[1];
-
-                if (closedSet.contains(neighbor)) continue;
+                if (closedSet.contains(neighbor)) {
+                    continue;
+                }
 
                 if (tentativeG < gScore.getOrDefault(neighbor, Double.MAX_VALUE)) {
                     gScore.put(neighbor, tentativeG);
                     openSet.add(new Node(neighbor, tentativeG, heuristic(neighbor, goal), current));
                 }
             }
         }
-
         return Collections.emptyList();
     }
 
     /**
-     * Simple heuristic: absolute difference between node indices.
-     *
-     * @param node current node
-     * @param goal goal node
-     * @return heuristic value
-     */
-    private double heuristic(int node, int goal) {
-        return Math.abs(goal - node);
-    }
-
-    /**
-     * Reconstructs the path from goal to start following parent links.
+     * Reconstructs the path by following parent nodes.
      *
      * @param node end node
-     * @return list of node indices from start to goal
+     * @return path from start to end
      */
     private List<Integer> reconstructPath(Node node) {
         List<Integer> path = new ArrayList<>();
@@ -179,4 +133,33 @@ private List<Integer> reconstructPath(Node node) {
         Collections.reverse(path);
         return path;
     }
+
+    /** Reads input dynamically and runs A* algorithm. */
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        AStarSearch aStar = new AStarSearch();
+
+        System.out.print("Enter number of edges: ");
+        int edges = sc.nextInt();
+        System.out.println("Enter edges in format: u v weight");
+        for (int i = 0; i < edges; i++) {
+            int u = sc.nextInt();
+            int v = sc.nextInt();
+            int w = sc.nextInt();
+            aStar.addEdge(u, v, w);
+        }
+
+        System.out.print("Enter start node: ");
+        int start = sc.nextInt();
+        System.out.print("Enter goal node: ");
+        int goal = sc.nextInt();
+
+        List<Integer> path = aStar.findPath(start, goal);
+        if (path.isEmpty()) {
+            System.out.println("No path found from " + start + " → " + goal);
+        } else {
+            System.out.println("Shortest path from " + start + " → " + goal + ": " + path);
+        }
+        sc.close();
+    }
 }