Last Updated on April 28, 2026 by Rajeev Bagra

If you are learning Python, artificial intelligence, or working through projects like Harvard’s CS50 AI or CS50W, you may come across a utility file containing classes such as Node, StackFrontier, and QueueFrontier.

At first glance, the code may look simple—but these classes power important search algorithms used in route finding, puzzle solving, shortest path problems, and graph traversal.

In this blog post, we’ll break down what each class does, why it matters, and how it helps solve real-world problems.

The Code Structure

class Node():
    def __init__(self, state, parent, action):
        self.state = state
        self.parent = parent
        self.action = action

class StackFrontier():

class QueueFrontier(StackFrontier):

These three classes work together to help a program explore possible paths and find solutions efficiently.

What Is a Node?

A Node represents one point in the search process.

Think of it as a record that stores:

• Current state → where you are now
• Parent → where you came from
• Action → how you got there

Example

Imagine traveling between cities:

Mumbai → Pune → Nashik

If you are currently in Pune:

• state = Pune
• parent = Mumbai
• action = drove via expressway

This lets the program reconstruct the full journey later.

Why Parent Is Important

When a search algorithm reaches the goal, it can trace backwards:

Goal → Parent → Parent → Parent

Then reverse the path.

That’s how apps like maps and AI pathfinders show the route.

What Is a Frontier?

A frontier is a collection of nodes waiting to be explored.

It stores all discovered possibilities that haven’t been checked yet.

Think of it like:

• tasks waiting in queue
• places left to visit
• moves left to test

StackFrontier: Depth-First Search (DFS)

class StackFrontier():

This frontier behaves like a stack.

Last item added = first item removed.

This is called:

LIFO = Last In, First Out

Example Stack

Add:

A
B
C

Remove gives:

C first.

Search Behavior

The algorithm keeps diving deeper before backtracking.

Like exploring a maze by always taking the newest corridor first.

Key Methods

Add Node

self.frontier.append(node)

Adds node to the stack.

Remove Node

node = self.frontier[-1]
self.frontier = self.frontier[:-1]

Removes the last added node.

Check Empty

len(self.frontier) == 0

Returns True if nothing remains.

Check Existing State

any(node.state == state for node in self.frontier)

Prevents duplicates.

QueueFrontier: Breadth-First Search (BFS)

class QueueFrontier(StackFrontier):

This class inherits everything from StackFrontier, but changes only the remove logic.

That means it reuses existing code smartly.

Queue Behavior

First item added = first item removed.

This is:

FIFO = First In, First Out

Like waiting in line at a store.

Remove Method

node = self.frontier[0]
self.frontier = self.frontier[1:]

Removes oldest item first.

Why BFS Is Powerful

Breadth-First Search explores level by level.

Example:

A connects to B and C
B connects to D
C connects to E

BFS explores:

A → B → C → D → E

This usually finds the shortest path in an unweighted graph.

DFS vs BFS Comparison

Real-World Uses

These concepts power many systems:

Navigation Apps

Finding shortest routes between places like Pune and Mumbai.

Social Networks

Finding how two people are connected.

Example:

Tom Hanks linked to Kevin Bacon through shared movies.

Puzzle Solvers

Sudoku, mazes, chess moves.

AI Systems

Robots choosing next moves.

Why Inheritance Is Used

class QueueFrontier(StackFrontier):

Instead of rewriting everything, Python lets one class reuse another.

Only the changing part (remove) is overridden.

This is cleaner and professional coding practice.

Mental Model

Node

Stores:

• Where am I?
• How did I get here?

Frontier

Stores:

• What should I explore next?

Simple Memory Trick

Node remembers the past. Frontier controls the future.

Final Thoughts

Even though these classes are short, they teach major programming ideas:

• Object-oriented programming
• Inheritance
• Data structures
• Search algorithms
• Problem solving

If you understand Node, StackFrontier, and QueueFrontier, you’re already learning the foundation of intelligent software systems.

Suggested Next Step

Try building:

• Maze solver
• Friend connection finder
• Movie actor path finder
• Route planner

That’s where these simple classes become powerful.