How Each Algorithm Works
A* (A-Star)
A* is an informed search algorithm that uses both the cost to reach a node (g) and an estimated cost to the goal (h, the heuristic). It evaluates nodes using f = g + h and always expands the node with the lowest f value. With an admissible heuristic like Manhattan distance, A* guarantees the shortest path while exploring fewer nodes than Dijkstra.
Dijkstra's Algorithm
Dijkstra's algorithm is a classic graph traversal method that explores nodes in order of their distance from the start. It uses a priority queue to always process the closest unvisited node next. While it guarantees the shortest path, it explores in all directions equally without considering the goal location, making it slower than A* for single-target searches.
Breadth-First Search (BFS)
BFS explores all nodes at distance d from the start before exploring nodes at distance d+1, using a queue (FIFO). On unweighted grids, BFS guarantees the shortest path because it finds the goal at the shallowest depth first. It's simple and complete but doesn't use edge weights or heuristics.
Depth-First Search (DFS)
DFS explores as far as possible along each branch before backtracking, using a stack (LIFO). It does not guarantee the shortest path and can get stuck exploring long paths before finding the goal. However, it uses less memory than BFS and can be useful for maze generation or exploring all possible paths.
Greedy Best-First Search
Greedy BFS uses only the heuristic (h) to prioritize nodes, always moving toward the node that appears closest to the goal. While very fast in simple cases, it does not guarantee the shortest path and can be misled by obstacles, exploring suboptimal routes before finding the goal.
Algorithm Comparison
| Algorithm |
Weighted? |
Shortest Path? |
Time Complexity |
Space Complexity |
| A* |
Yes |
Yes (with admissible heuristic) |
O(b^d) |
O(b^d) |
| Dijkstra |
Yes |
Yes |
O((V + E) log V) |
O(V) |
| BFS |
No |
Yes (unweighted) |
O(V + E) |
O(V) |
| DFS |
No |
No |
O(V + E) |
O(h) (h = height) |
| Greedy BFS |
No |
No |
O(b^m) |
O(b^m) |
V = vertices, E = edges, b = branching factor, d = depth of solution, m = maximum depth, h = height of tree
Frequently Asked Questions
What pathfinding algorithms does this visualizer support?
This visualizer supports 5 algorithms: A* (A-star), Dijkstra, Breadth-First Search (BFS), Depth-First Search (DFS), and Greedy Best-First Search. Each one animates in real time showing visited nodes and the final shortest path.
What is the difference between A* and Dijkstra?
Dijkstra explores all directions equally and guarantees the shortest path. A* uses a heuristic (estimated distance to the goal) to prioritize exploring nodes closer to the target, making it faster while still guaranteeing the shortest path.
Does BFS find the shortest path?
Yes, BFS guarantees the shortest path on an unweighted grid because it explores all nodes at distance d before exploring nodes at distance d+1. DFS does not guarantee the shortest path.
Does this tool store any data?
No. All visualizations run entirely in your browser. No data is sent to any server.
How do I draw walls on the grid?
Click and drag on any empty cell to draw walls. You can also click individual cells. To remove walls, click "Clear Walls" or drag over existing walls while holding the mouse button.
Can I move the start and end points?
Yes. Click on the green (start) or red (end) node and it will enter placement mode. Click anywhere on the grid to place it in a new location.
What does the diagonal movement option do?
When enabled, algorithms can move diagonally (8 directions) instead of just up/down/left/right (4 directions). This often results in shorter paths but explores more nodes.
Privacy & Data
This pathfinding visualizer runs entirely in your browser using JavaScript. No grid configurations, algorithms, or any data are transmitted to our servers or any third party. Your learning and experimentation remain completely private.