8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

Search...

A* Search Algorithm
Last Updated : 23 Jul, 2025

Motivation
To approximate the shortest path in real-life situations, like- in maps, games
where there can be many hindrances.
We can consider a 2D Grid having several obstacles and we start from a
source cell (colored red below) to reach towards a goal cell (colored green
below)

What is A* Search Algorithm?

A* Search algorithm is one of the best and popular technique used in path-
finding and graph traversals.

Why A* Search Algorithm?

Informally speaking, A* Search algorithms, unlike other traversal techniques,
it has “brains”. What it means is that it is really a smart algorithm which
separates it from the other conventional algorithms. This fact is cleared in
detail in below sections.
And it is also worth mentioning that many games and web-based maps use
this algorithm to find the shortest path very efficiently (approximation).

Explanation
https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 1/14
8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

Consider a square grid having many obstacles and we are given a starting
cell and a target cell. We want to reach the target cell (if possible) from the
starting cell as quickly as possible. Here A* Search Algorithm comes to the
rescue.
What A* Search Algorithm does is that at each step it picks the node
according to a value-‘f’ which is a parameter equal to the sum of two other
parameters - ‘g’ and ‘h’. At each step it picks the node/cell having the lowest
‘f’, and process that node/cell.
We define ‘g’ and ‘h’ as simply as possible below
g = the movement cost to move from the starting point to a given square on
the grid, following the path generated to get there.
h = the estimated movement cost to move from that given square on the grid
to the final destination. This is often referred to as the heuristic, which is
nothing but a kind of smart guess. We really don’t know the actual distance
until we find the path, because all sorts of things can be in the way (walls,
water, etc.). There can be many ways to calculate this ‘h’ which are
discussed in the later sections.

Algorithm
We create two lists – Open List and Closed List (just like Dijkstra
Algorithm)

// A* Search Algorithm
1. Initialize the open list
2. Initialize the closed list
put the starting node on the open
list (you can leave its f at zero)
3. while the open list is not empty
a) find the node with the least f on
the open list, call it "q"
b) pop q off the open list

c) generate q's 8 successors and set their

parents to q

d) for each successor

i) if successor is the goal, stop search

ii) else, compute both g and h for successor

successor.g = q.g + distance between
successor and q
https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 2/14
8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

successor.h = distance from goal to

successor (This can be done using many
ways, we will discuss three heuristics-
Manhattan, Diagonal and Euclidean
Heuristics)

successor.f = successor.g + successor.h

iii) if a node with the same position as
successor is in the OPEN list which has a
lower f than successor, skip this successor
iV) if a node with the same position as
successor is in the CLOSED list which has
a lower f than successor, skip this successor
otherwise, add the node to the open list
end (for loop)

e) push q on the closed list

end (while loop)

So suppose as in the below figure if we want to reach the target cell from
the source cell, then the A* Search algorithm would follow path as shown
below. Note that the below figure is made by considering Euclidean Distance
as a heuristics.

Heuristics
We can calculate g but how to calculate h ?
We can do things.

https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 3/14
8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

A) Either calculate the exact value of h (which is certainly time consuming).

OR
B ) Approximate the value of h using some heuristics (less time consuming).
We will discuss both of the methods.
A) Exact Heuristics -
We can find exact values of h, but that is generally very time consuming.
Below are some of the methods to calculate the exact value of h.
1) Pre-compute the distance between each pair of cells before running the
A* Search Algorithm.
2) If there are no blocked cells/obstacles then we can just find the exact
value of h without any pre-computation using the distance
formula/Euclidean Distance

B) Approximation Heuristics -
There are generally three approximation heuristics to calculate h -

1) Manhattan Distance -

It is nothing but the sum of absolute values of differences in the goal’s x

and y coordinates and the current cell’s x and y coordinates respectively,
i.e.,

h = abs (current_cell.x – goal.x) +

abs (current_cell.y – goal.y)

When to use this heuristic? – When we are allowed to move only in four
directions only (right, left, top, bottom)

The Manhattan Distance Heuristics is shown by the below figure (assume

red spot as source cell and green spot as target cell).

https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 4/14
8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

2) Diagonal Distance-

It is nothing but the maximum of absolute values of differences in the

goal’s x and y coordinates and the current cell’s x and y coordinates
respectively, i.e.,

dx = abs(current_cell.x – goal.x)
dy = abs(current_cell.y – goal.y)

h = D * (dx + dy) + (D2 - 2 * D) * min(dx, dy)

where D is length of each node(usually = 1) and D2 is diagonal
distance between each node (usually = sqrt(2) ).

When to use this heuristic? – When we are allowed to move in eight

directions only (similar to a move of a King in Chess)

The Diagonal Distance Heuristics is shown by the below figure (assume red
spot as source cell and green spot as target cell).

https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 5/14
8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

3) Euclidean Distance-

As it is clear from its name, it is nothing but the distance between the
current cell and the goal cell using the distance formula

h = sqrt ( (current_cell.x – goal.x)2 +

(current_cell.y – goal.y)2 )

When to use this heuristic? – When we are allowed to move in any

directions.

The Euclidean Distance Heuristics is shown by the below figure (assume red
spot as source cell and green spot as target cell).

Relation (Similarity and Differences) with other algorithms-

https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 6/14
8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

Dijkstra is a special case of A* Search Algorithm, where h = 0 for all nodes.

Implementation
We can use any data structure to implement open list and closed list but for
best performance, we use a set data structure of C++ STL(implemented as
Red-Black Tree) and a boolean hash table for a closed list.
The implementations are similar to Dijkstra's algorithm. If we use a Fibonacci
heap to implement the open list instead of a binary heap/self-balancing tree,
then the performance will become better (as Fibonacci heap takes O(1)
average time to insert into open list and to decrease key)

Also to reduce the time taken to calculate g, we will use dynamic

programming.

C++ Java Python C# JavaScript

import math
import heapq

# Define the Cell class

class Cell:
def __init__(self):
self.parent_i = 0 # Parent cell's row index
self.parent_j = 0 # Parent cell's column index
self.f = float('inf') # Total cost of the cell (g + h)
self.g = float('inf') # Cost from start to this cell
self.h = 0 # Heuristic cost from this cell to destination

# Define the size of the grid

ROW = 9
COL = 10

# Check if a cell is valid (within the grid)

def is_valid(row, col):
return (row >= 0) and (row < ROW) and (col >= 0) and (col <
COL)

# Check if a cell is unblocked

def is_unblocked(grid, row, col):
return grid[row][col] == 1

# Check if a cell is the destination

def is_destination(row, col, dest):
return row == dest[0] and col == dest[1]

https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 7/14
8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

# Calculate the heuristic value of a cell (Euclidean distance to

destination)
def calculate_h_value(row, col, dest):
return ((row - dest[0]) ** 2 + (col - dest[1]) ** 2) ** 0.5

# Trace the path from source to destination

def trace_path(cell_details, dest):
print("The Path is ")
path = []
row = dest[0]
col = dest[1]

# Trace the path from destination to source using parent cells

while not (cell_details[row][col].parent_i == row and
cell_details[row][col].parent_j == col):
path.append((row, col))
temp_row = cell_details[row][col].parent_i
temp_col = cell_details[row][col].parent_j
row = temp_row
col = temp_col

# Add the source cell to the path

path.append((row, col))
# Reverse the path to get the path from source to destination
path.reverse()

# Print the path

for i in path:
print("->", i, end=" ")
print()

# Implement the A* search algorithm

def a_star_search(grid, src, dest):
# Check if the source and destination are valid
if not is_valid(src[0], src[1]) or not is_valid(dest[0],
dest[1]):
print("Source or destination is invalid")
return

# Check if the source and destination are unblocked

if not is_unblocked(grid, src[0], src[1]) or not
is_unblocked(grid, dest[0], dest[1]):
print("Source or the destination is blocked")
return

# Check if we are already at the destination

if is_destination(src[0], src[1], dest):

https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 8/14
8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

print("We are already at the destination")

return

# Initialize the closed list (visited cells)

closed_list = [[False for _ in range(COL)] for _ in
range(ROW)]
# Initialize the details of each cell
cell_details = [[Cell() for _ in range(COL)] for _ in
range(ROW)]

# Initialize the start cell details

i = src[0]
j = src[1]
cell_details[i][j].f = 0
cell_details[i][j].g = 0
cell_details[i][j].h = 0
cell_details[i][j].parent_i = i
cell_details[i][j].parent_j = j

# Initialize the open list (cells to be visited) with the

start cell
open_list = []
heapq.heappush(open_list, (0.0, i, j))

# Initialize the flag for whether destination is found

found_dest = False

# Main loop of A* search algorithm

while len(open_list) > 0:
# Pop the cell with the smallest f value from the open
list
p = heapq.heappop(open_list)

# Mark the cell as visited

i = p[1]
j = p[2]
closed_list[i][j] = True

# For each direction, check the successors

directions = [(0, 1), (0, -1), (1, 0), (-1, 0), (1, 1),
(1, -1), (-1, 1), (-1, -1)]
for dir in directions:
new_i = i + dir[0]
new_j = j + dir[1]

# If the successor is valid, unblocked, and not

visited

https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 9/14
8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

if is_valid(new_i, new_j) and is_unblocked(grid,

new_i, new_j) and not closed_list[new_i][new_j]:
# If the successor is the destination
if is_destination(new_i, new_j, dest):
# Set the parent of the destination cell
cell_details[new_i][new_j].parent_i = i
cell_details[new_i][new_j].parent_j = j
print("The destination cell is found")
# Trace and print the path from source to
destination
trace_path(cell_details, dest)
found_dest = True
return
else:
# Calculate the new f, g, and h values
g_new = cell_details[i][j].g + 1.0
h_new = calculate_h_value(new_i, new_j, dest)
f_new = g_new + h_new

# If the cell is not in the open list or the

new f value is smaller
if cell_details[new_i][new_j].f ==
float('inf') or cell_details[new_i][new_j].f > f_new:
# Add the cell to the open list
heapq.heappush(open_list, (f_new, new_i,
new_j))
# Update the cell details
cell_details[new_i][new_j].f = f_new
DSA Tutorial Data Structures Algorithms Array Strings Linked List Stack
cell_details[new_i][new_j].g = g_new Sign In
cell_details[new_i][new_j].h = h_new
cell_details[new_i][new_j].parent_i = i
cell_details[new_i][new_j].parent_j = j

# If the destination is not found after visiting all cells

if not found_dest:
print("Failed to find the destination cell")

def main():
# Define the grid (1 for unblocked, 0 for blocked)
grid = [
[1, 0, 1, 1, 1, 1, 0, 1, 1, 1],
[1, 1, 1, 0, 1, 1, 1, 0, 1, 1],
[1, 1, 1, 0, 1, 1, 0, 1, 0, 1],
[0, 0, 1, 0, 1, 0, 0, 0, 0, 1],
[1, 1, 1, 0, 1, 1, 1, 0, 1, 0],
[1, 0, 1, 1, 1, 1, 0, 1, 0, 0],
[1, 0, 0, 0, 0, 1, 0, 0, 0, 1],

https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 10/14
8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

[1, 0, 1, 1, 1, 1, 0, 1, 1, 1],
[1, 1, 1, 0, 0, 0, 1, 0, 0, 1]
]

# Define the source and destination

src = [8, 0]
dest = [0, 0]

# Run the A* search algorithm

a_star_search(grid, src, dest)

if __name__ == "__main__":
main()

Limitations
Although being the best path finding algorithm around, A* Search Algorithm
doesn’t produce the shortest path always, as it relies heavily on heuristics /
approximations to calculate - h

Applications
This is the most interesting part of A* Search Algorithm. They are used in
games! But how?
Ever played Tower Defense Games ?
Tower defense is a type of strategy video game where the goal is to defend
a player's territories or possessions by obstructing enemy attackers, usually
achieved by placing defensive structures on or along their path of attack.
A* Search Algorithm is often used to find the shortest path from one point to
another point. You can use this for each enemy to find a path to the goal.
One example of this is the very popular game- Warcraft III

What if the search space is not a grid and is a graph ?

The same rules applies there also. The example of grid is taken for the
simplicity of understanding. So we can find the shortest path between the
source node and the target node in a graph using this A* Search Algorithm,
just like we did for a 2D Grid.

Time Complexity
Considering a graph, it may take us to travel all the edge to reach the
destination cell from the source cell [For example, consider a graph where
source and destination nodes are connected by a series of edges, like -
0(source) -->1 --> 2 --> 3 (target)

https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 11/14
8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

So the worse case time complexity is O(E), where E is the number of edges
in the graph

Auxiliary Space In the worse case we can have all the edges inside the open
list, so required auxiliary space in worst case is O(V), where V is the total
number of vertices.

Exercise to the Readers-

Ever wondered how to make a game like- Pacman where there are many
such obstacles. Can we use A* Search Algorithm to find the correct way ?
Think about it as a fun exercise.

Articles for interested readers

In our program, the obstacles are fixed. What if the obstacles are moving ?
Interested readers may see here an excellent discussion on this topic.

Summary
So when to use BFS over A*, when to use Dijkstra over A* to find the
shortest paths ?
We can summarise this as below-
1) One source and One Destination-
? Use A* Search Algorithm (For Unweighted as well as Weighted Graphs)
2) One Source, All Destination -
? Use BFS (For Unweighted Graphs)
? Use Dijkstra (For Weighted Graphs without negative weights)
? Use Bellman Ford (For Weighted Graphs with negative weights)
3) Between every pair of nodes-
? Floyd-Warshall
? Johnson’s Algorithm

Related Article:
Best First Search (Informed Search)

References-
http://theory.stanford.edu/~amitp/GameProgramming/
https://en.wikipedia.org/wiki/A*_search_algorithm

Comment More info Advertise with us

https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 12/14
8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

Explore
Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Corporate & Communications Address:

A-143, 7th Floor, Sovereign Corporate
Tower, Sector- 136, Noida, Uttar Pradesh
(201305)

Registered Address:
K 061, Tower K, Gulshan Vivante
Apartment, Sector 137, Noida, Gautam
Buddh Nagar, Uttar Pradesh, 201305

Advertise with us

https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 13/14
8/29/25, 6:53 PM A* Search Algorithm - GeeksforGeeks

Company Explore
About Us POTD
Legal Job-A-Thon
Privacy Policy Community
Contact Us Videos
Advertise with us Blogs
GFG Corporate Solution Nation Skill Up
Campus Training Program

Tutorials Courses
Programming Languages IBM Certification
DSA DSA and Placements
Web Technology Web Development
AI, ML & Data Science Programming Languages
DevOps DevOps & Cloud
CS Core Subjects GATE
Interview Preparation Trending Technologies
GATE
Software and Tools

Videos Preparation Corner

DSA Aptitude
Python Puzzles
Java GfG 160
C++ DSA 360
Web Development System Design
Data Science
CS Subjects

@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved

https://www.geeksforgeeks.org/dsa/a-search-algorithm/ 14/14