A-star algorithm¶

A (pronounced "A-star") is a graph traversal and pathfinding algorithm that is used in many fields of computer science due to its completeness, optimality, and optimal efficiency.*

Version: v1 · 2026-09-28 · History
Domain-specific #: 7816
Domain group: Applied Sciences & Engineering
Origin domain: Computer Science & Software Engineering
Subdomains: Artificial Intelligence, Heuristic Search → Computer Science & Software Engineering

Core Idea¶

A-star algorithm is treated here as the recurring mathematics_logic_statistics identity summarized by this source-grounded definition: A* (pronounced "A-star") is a graph traversal and pathfinding algorithm that is used in many fields of computer science due to its completeness, optimality, and optimal efficiency.

A* (pronounced "A-star") is a graph traversal and pathfinding algorithm that is used in many fields of computer science due to its completeness, optimality, and optimal efficiency. Given a weighted graph, a source node and a goal node, the algorithm finds the shortest path (with respect to the given weights) from source to goal. One major practical drawback is its O(b^d) space complexity where is the depth of the shallowest solution (the length of the shortest path from the source node to any given goal node) and is the branching factor (the maximum number of successors for any given state).

In practical travel-routing systems, it is generally outperformed by algorithms that can pre-process the graph to attain better performance, as well as by memory-bounded approaches; however, A* is still the best solution in many cases. Peter Hart, Nils Nilsson and Bertram Raphael of Stanford Research Institute (now SRI International) first published the algorithm in 1968. It can be seen as an extension of Dijkstra's algorithm.

For A-star algorithm, the abstraction is narrower than the article's general subject matter: a positive case must preserve A* (pronounced "A-star") is a graph traversal and pathfinding algorithm that is used in many fields of computer science due to its completeness, optimality, and optimal efficiency. Retaining only the name, a familiar example, or a downstream effect is insufficient. The specialist roles and tests remain anchored in mathematics_logic_statistics, which is why this identity is domain-specific rather than prime.

How would you explain it like I'm…

Smart Shortest-Path Finder

Imagine finding the shortest way through a maze of roads to your friend's house. At every turn you think, 'how far have I come, and about how far is still left?' and you try the most promising road next. A-star is a way computers do this so they find the shortest route without checking every single road.

Guess-Ahead Route Finder

The A-star (A*) algorithm finds the shortest path from a start to a goal in a network of places connected by roads with different lengths — computer scientists call this a weighted graph. It keeps a list of places to explore and always picks the one that looks best, based on the distance travelled so far plus a guess of the distance still to go. This lets it head toward the goal instead of spreading out in every direction. It was published in 1968 by researchers at Stanford Research Institute and builds on an older method called Dijkstra's algorithm. Its main weakness is that it can use a lot of memory.

Heuristic-Guided Shortest-Path Search

A* is a graph traversal and pathfinding algorithm: given a weighted graph, a source node and a goal node, it finds the shortest path with respect to the weights. It extends Dijkstra's algorithm by ranking nodes to explore using the cost so far plus an estimate of the remaining cost to the goal, which focuses the search. It is valued for being complete (it finds a path if one exists), optimal (the path it finds is shortest), and optimally efficient. Its big practical drawback is memory: it can need space that grows like b^d, where b is the branching factor and d is the depth of the shortest solution. In real-world travel routing, methods that pre-process the map or limit memory often beat it, but A* is still the best choice in many cases.

A* is a best-first graph search and pathfinding algorithm, published in 1968 by Peter Hart, Nils Nilsson and Bertram Raphael of Stanford Research Institute. Given a weighted graph, a source and a goal, it returns a shortest path with respect to the edge weights. It can be seen as an extension of Dijkstra's algorithm: nodes are expanded in order of the path cost from the source plus a heuristic estimate of the remaining cost to the goal, which directs search toward the goal. It is widely used because of its completeness, optimality, and optimal efficiency (guarantees that depend on the heuristic satisfying the appropriate conditions). Its chief practical drawback is O(b^d) space complexity, where b is the branching factor and d the depth of the shallowest solution. In travel-routing systems it is often outperformed by algorithms that preprocess the graph and by memory-bounded approaches, but it remains the best solution in many settings.

Structural Signature¶

Sig role-phrases:

Defining carrier — In practical travel-routing systems, it is generally outperformed by algorithms that can pre-process the graph to attain better performance, as well as by memory-bounded approaches; however, A* is still the best solution in many cases.
Constitutive relation — Graph Traverser is guided by a heuristic function , the estimated distance from node to the goal node: it entirely ignores , the distance from the start node to .
Operating condition — It does this by maintaining a tree of paths originating at the start node and extending those paths one edge at a time until the goal node is reached.
Recognition evidence — With a consistent heuristic, A* is guaranteed to find an optimal path without processing any node more than once and A* is equivalent to running Dijkstra's algorithm with the reduced cost .
Admissible variation — // how cheap a path could be from start to finish if it goes through n.
Characteristic consequence — Remark: In this pseudocode, if a node is reached by one path, removed from open_set , and subsequently reached by a cheaper path, it will be added to open_set again.
Failure boundary — General depth-first search can be implemented using A* by considering that there is a global counter C initialized with a very large value.

What It Is Not¶

Not the whole field of mathematics_logic_statistics. The node requires the specific identity stated by A* (pronounced "A-star") is a graph traversal and pathfinding algorithm that is used in many fields of computer science due to its completeness, optimality, and optimal efficiency.
Not an over-broad reading. // This is usually implemented as a min-heap or priority queue rather than a hash-set.
Not an over-broad reading. This is essential to guarantee that the path returned is optimal if the heuristic function is admissible but not consistent.
Not an over-broad reading. If these references are being kept then it can be important that the same node doesn't appear in the priority queue more than once (each entry corresponding to a different path to the node, and each with a different cost).
Not automatically Shortest path problem. Retrieval proximity does not establish equivalence; the two identities must be compared by carrier, operation, and failure boundary.

Scope of Application¶

A-star algorithm applies literally inside mathematics_logic_statistics wherever the source-defined carrier and relation can be established. Its documented habitats include:

Admissibility. If the heuristic function used by A* is admissible, then A* is admissible.
Applications. A* is often used for the common pathfinding problem in applications such as video games, but was originally designed as a general graph traversal algorithm.
History. Graph Traverser is guided by a heuristic function , the estimated distance from node to the goal node: it entirely ignores , the distance from the start node to .
History. Peter Hart invented the concepts we now call admissibility and consistency of heuristic functions.
History. The original 1968 A* paper contained a theorem stating that no A-like algorithm could expand fewer nodes than A if the heuristic function is consistent and A*'s tie-breaking rule is suitably chosen.
Description. where is the next node on the path, is the cost of the path from the start node to , and is a heuristic function that estimates the cost of the cheapest path from to the goal.

Outside mathematics_logic_statistics, the name should be retained only when these same operational conditions survive; otherwise the comparison belongs to the broader parent Pattern or should be marked as analogy.

Clarity¶

A clear use of A-star algorithm names the carrier, the operative relation, and the conditions under which the source treats the identity as present. The minimal definition is A* (pronounced "A-star") is a graph traversal and pathfinding algorithm that is used in many fields of computer science due to its completeness, optimality, and optimal efficiency. The strongest recognition evidence in the frozen account is: With a consistent heuristic, A* is guaranteed to find an optimal path without processing any node more than once and A* is equivalent to running Dijkstra's algorithm with the reduced cost . A report should distinguish that evidence from a proxy, consequence, or common implementation. It should also state the qualification // This is usually implemented as a min-heap or priority queue rather than a hash-set. so that a reader can reproduce the classification rather than infer it from topical resemblance.

Manages Complexity¶

A-star algorithm compresses multiple mathematics_logic_statistics details into a stable diagnostic relation. The source shows both the central mechanism—graph Traverser is guided by a heuristic function , the estimated distance from node to the goal node: it entirely ignores , the distance from the start node to .—and the practical consequence—remark: In this pseudocode, if a node is reached by one path, removed from open_set , and subsequently reached by a cheaper path, it will be added to open_set again. This compression makes cases comparable while leaving parameters, conventions, exceptions, and evidential quality explicit. It is lossy by design: local history and implementation details may be omitted only when they do not alter the defining relation.

Abstract Reasoning¶

Type the carrier. Identify the mathematics_logic_statistics entities to which the claim applies.
State the relation. Use the source-grounded identity: A* (pronounced "A-star") is a graph traversal and pathfinding algorithm that is used in many fields of computer science due to its completeness, optimality, and optimal efficiency.
Check operation and conditions. It does this by maintaining a tree of paths originating at the start node and extending those paths one edge at a time until the goal node is reached.
Demand recognition evidence. With a consistent heuristic, A* is guaranteed to find an optimal path without processing any node more than once and A* is equivalent to running Dijkstra's algorithm with the reduced cost .
Test variation. Change an implementation or setting while preserving // how cheap a path could be from start to finish if it goes through n.
Run the collapse test. Remove the defining operation; if the label still seems equally apt, only a topic or correlate was retained.
Reduce cautiously. When the specialist conditions cannot be carried, route the residual comparison to Pattern.

Knowledge Transfer¶

Within the home domain. Knowledge about A-star algorithm transfers literally when a new case preserves the same carrier type, relation, and recognition test. If the heuristic function used by A* is admissible, then A* is admissible. A* is often used for the common pathfinding problem in applications such as video games, but was originally designed as a general graph traversal algorithm.

Beyond the home domain. No canonical parent is asserted for A-star algorithm. An outside case receives the specialist name only when the same typed roles and rejection conditions can be filled literally; otherwise the comparison remains an analogy pending later graph densification.

Examples¶

Canonical¶

Therefore, no optimal algorithm including A* could expand fewer nodes than C^{*} in the worst case. This case is canonical because it supplies a concrete carrier and lets the defining relation be checked rather than merely named.

Mapped back: carrier → the entities in the documented case; operation → A* (pronounced "A-star") is a graph traversal and pathfinding algorithm that is used in many fields of computer science due to its completeness, optimality, and optimal efficiency; recognition evidence → With a consistent heuristic, A* is guaranteed to find an optimal path without processing any node more than once and A* is equivalent to running Dijkstra's algorithm with the reduced cost

Applied / In Practice¶

Dijkstra's algorithm, as another example of a uniform-cost search algorithm, can be viewed as a special case of A* where for all x. The applied case shows how the identity is used under a second setting or qualification while keeping the same operative relation.

Mapped back: changed setting → Special cases; invariant → A* (pronounced "A-star") is a graph traversal and pathfinding algorithm that is used in many fields of computer science due to its completeness, optimality, and optimal efficiency; boundary → the case exits the class when // This is usually implemented as a min-heap or priority queue rather than a hash-set

Structural Tensions¶

T1 — Stable identity versus admissible variation. // This is usually implemented as a min-heap or priority queue rather than a hash-set. The tension matters because emphasizing only one side either dissolves the identity or overstates what the evidence and domain conventions warrant.

Diagnostic: Which changes preserve the defining relation, and which replace it?

T2 — Recognition versus proxy. This is essential to guarantee that the path returned is optimal if the heuristic function is admissible but not consistent. The tension matters because emphasizing only one side either dissolves the identity or overstates what the evidence and domain conventions warrant.

Diagnostic: Does the cited evidence establish the identity or only a correlated sign?

T3 — Definition versus implementation. If these references are being kept then it can be important that the same node doesn't appear in the priority queue more than once (each entry corresponding to a different path to the node, and each with a different cost). The tension matters because emphasizing only one side either dissolves the identity or overstates what the evidence and domain conventions warrant.

Diagnostic: Is the observed implementation constitutive, optional, or merely common?

T4 — Scope versus overextension. Call a node closed if it has been visited and is not in the open set. The tension matters because emphasizing only one side either dissolves the identity or overstates what the evidence and domain conventions warrant.

Diagnostic: Can every claimed application fill the same typed roles without metaphor?

T5 — Transfer versus domain accent. In practical travel-routing systems, it is generally outperformed by algorithms that can pre-process the graph to attain better performance, as well as by memory-bounded approaches; however, A* is still the best solution in many cases. The tension matters because emphasizing only one side either dissolves the identity or overstates what the evidence and domain conventions warrant.

Diagnostic: Does the receiving case instantiate A-star algorithm literally, co-instantiate Pattern, or only resemble it?

T6 — Autonomy versus reduction. Graph Traverser is guided by a heuristic function , the estimated distance from node to the goal node: it entirely ignores , the distance from the start node to . The tension matters because emphasizing only one side either dissolves the identity or overstates what the evidence and domain conventions warrant.

Diagnostic: What does A-star algorithm distinguish that the broader parent Pattern leaves together?

Structural–Framed Character¶

A-star algorithm is structural-leaning. Its structural side is the repeatable organization summarized by A* (pronounced "A-star") is a graph traversal and pathfinding algorithm that is used in many fields of computer science due to its completeness, optimality, and optimal efficiency. Its framed side is the mathematics_logic_statistics vocabulary that fixes the carrier, evidence, exceptions, and admissible transformations.

Evaluative weight: the identity can be stated descriptively even when applications carry practical stakes. Human-practice dependence: the source-grounded carrier determines whether the relation exists independently or is constituted by a practice. Institutional origin: disciplinary conventions stabilize the name and test. Vocabulary portability: It does this by maintaining a tree of paths originating at the start node and extending those paths one edge at a time until the goal node is reached. Import versus recognition: literal transfer requires the same mechanism; shape alone is analogy.

Its portable skeleton is Pattern. Its character: a recurring specialist identity whose thin organization can be abstracted, while its operational meaning remains domain-bound.

Structural Core vs. Domain Accent¶

What is skeletal. A* (pronounced "A-star") is a graph traversal and pathfinding algorithm that is used in many fields of computer science due to its completeness, optimality, and optimal efficiency. The stable skeleton is the typed relation expressed in that definition and the entry's recognition and collapse tests. The source identifies these operative conditions: In practical travel-routing systems, it is generally outperformed by algorithms that can pre-process the graph to attain better performance, as well as by memory-bounded approaches; however, A is still the best solution in many cases. Graph Traverser is guided by a heuristic function , the estimated distance from node to the goal node: it entirely ignores , the distance from the start node to . It further constrains recognition and variation through: It does this by maintaining a tree of paths originating at the start node and extending those paths one edge at a time until the goal node is reached. With a consistent heuristic, A is guaranteed to find an optimal path without processing any node more than once and A is equivalent to running Dijkstra's algorithm with the reduced cost .

What is domain-bound. mathematics logic statistics supplies the operative entities, technical vocabulary, warrants, and exceptions that make A-star algorithm literal. Its documented scope includes the condition that If the heuristic function used by A is admissible, then A is admissible. Another bounded application condition is that A is often used for the common pathfinding problem in applications such as video games, but was originally designed as a general graph traversal algorithm. These are not decorative examples; they determine which carrier and evidence can fill the abstraction's roles.

Why no parent is asserted. Removing those specialist details does not currently yield one live catalog node that is a necessary genus for every instance. The entry is therefore approved as unparented rather than attached by topical resemblance. Its collapse evidence remains specific—// how cheap a path could be from start to finish if it goes through n.—and future graph densification may discover a defensible relation only if it preserves that boundary.

This entry is a kind of Search Algorithm.

Approved unparented node. No current live node supplies a defensible necessary genus or structural prerequisite for A-star algorithm. The reviewed identity is: A* (pronounced "A-star") is a graph traversal and pathfinding algorithm that is used in many fields of computer science due to its completeness, optimality, and optimal efficiency. The accelerated suggestion was declined because topical or lexical similarity does not establish hierarchy; the node is admitted without a parent pending later graph densification.
Related reasoning operations. Evidence, representation, comparison, classification, transformation, or evaluation may participate in particular cases, but participation does not make any one of them a necessary parent of every instance.

Relationships to Other Abstractions¶

Current abstraction A-star algorithm Domain-specific

Parents (1) — more general patterns this builds on

A-star algorithm is a kind of Search Algorithm Domain-specific

A* is a search algorithm that orders graph exploration by accumulated cost plus a heuristic estimate.

Neighborhood in Abstraction Space¶

A-star algorithm sits in a moderately populated region (47^th percentile for distinctiveness): it has near-neighbors but no dense thicket of look-alikes.

Family — Combinatorial Optimization & Discrete Structures (31 abstractions)

Nearest neighbors

Computed from structural-signature embeddings · 2026-10-08

Not to Be Confused With¶

Pattern. The parent omits the specialist differentia. Tell: Can the case establish A* (pronounced "A-star") is a graph traversal and pathfinding algorithm that is used in many fields of computer science due to its completeness, optimality, and optimal efficiency?
Shortest path problem. The optimization problem of finding a path between specified graph vertices whose accumulated edge or path weight is minimal among all admissible paths. Tell: Which entry's carrier, operation, and failure condition are satisfied?
Star height problem. The formal-language problem of determining the minimum nesting depth of Kleene stars needed to express a regular language and how that depth can be decided. Tell: Which entry's carrier, operation, and failure condition are satisfied?
Path. An ordered, traversable sequence of edges connecting one node to another through a relational structure. Tell: Which entry's carrier, operation, and failure condition are satisfied?
A measurement, proxy, or consequence. Those may provide evidence without being the identity. Tell: Would A-star algorithm remain present if the detector or downstream effect changed?
A metaphorical analogue. A similar shape outside mathematics_logic_statistics lacks the specialist mechanism. Tell: Do the native roles transfer literally, or only the parent Pattern?

References¶

Frozen Wikipedia discovery revision: https://en.wikipedia.org/wiki/A*_search_algorithm (revision 1363312727).
Preserved source candidate: https://zenodo.org/record/979689
Preserved source candidate: https://ai.stanford.edu/~nilsson/QAI/qai.pdf
Preserved source candidate: http://www.aaai.org/Papers/AAAI/2005/AAAI05-216.pdf
Preserved source candidate: https://www.ics.uci.edu/~dechter/publications/r0.pdf
Preserved source candidate: https://www.lix.polytechnique.fr/~liberti/bidirtimedepj.pdf
Preserved source candidate: https://books.google.com/books?id=SULMdT8qPwEC&pg=PA344
Preserved source candidate: https://books.google.com/books?id=9_AXCmGDiz8C&pg=PA214
Preserved source candidate: https://web.archive.org/web/20220215222823/https://books.google.com/books?id=9_AXCmGDiz8C&pg=PA214

The frozen Wikipedia revision is discovery provenance. The retained source set was reviewed for identity, formal or operational relation, and scope. The encyclopedia's structural synthesis is bounded to those claims; a thin authority surface is recorded as a nonblocking source-strengthening repair rather than concealed.