Graphs: Structure, Representation, and Traversal

A foundational reading that introduces graph data structures by explaining what graphs are, why they are more flexible than arrays, linked lists, and trees, and where they appear in real-world computing; learners read it to build conceptual context before studying specific graph topics.

A reading that distinguishes directed graphs (edges with a one-way direction) from undirected graphs (symmetric edges), covering related terminology such as degree, paths, and cycles, so learners can correctly classify and reason about graph relationships.

A reading that explains the adjacency matrix storage format for graphs, covering how to build and interpret the matrix, its memory cost, and the time complexity of common operations, so learners can evaluate when this representation is appropriate.

A reading that explains the adjacency list storage format for graphs, covering how lists of neighbors are stored, their memory and time-complexity trade-offs compared with adjacency matrices, and how to implement them, so learners can choose and apply the most practical representation for sparse graphs.

A reading that explains the Breadth-First Search algorithm, covering its layer-by-layer traversal logic, queue-based implementation, visited tracking, and use cases such as shortest-path finding in unweighted graphs, so learners understand how to explore graphs level by level.

A reading that explains the Depth-First Search algorithm, covering its recursive and stack-based implementations, backtracking behavior, visited tracking, and applications such as cycle detection and topological sorting, so learners understand how to explore graphs along deep paths before backtracking.

A hands-on coding reading that walks learners through building a JavaScript Graph class from scratch, then adding BFS and DFS methods step by step, so they can translate traversal concepts into working, runnable code.

An introductory reading that defines graphs in terms of vertices and edges, contrasts them with arrays, lists, and trees, and shows real-world systems they model, giving learners the vocabulary needed before tackling representations and traversals.

A lesson distinguishing directed from undirected graphs, explaining how edge direction changes the meaning of a connection and illustrating it with examples like friendships, road networks, web links, and course prerequisites so learners can choose the right model for a problem.

A reading on storing a graph as an n-by-n adjacency matrix, covering how row/column entries encode edges, how to look up or add an edge, and the space and time trade-offs, which learners use to decide when a matrix is the right representation.

A lesson on the adjacency list representation, showing how each vertex keeps a list of its neighbors (typically with JavaScript objects, arrays, or maps) and why this is the default choice for sparse graphs and traversal algorithms.

A tutorial on Breadth-First Search that explains level-by-level exploration from a source vertex using a queue and a visited set, teaching learners how to trace BFS by hand and apply it to shortest-path and layer-based problems.

A tutorial on Depth-First Search that explains going as deep as possible along each branch before backtracking, contrasts it with BFS, and prepares learners to implement DFS recursively or with an explicit stack.

A hands-on coding lesson in which learners build a reusable JavaScript Graph class backed by an adjacency list and implement BFS and DFS methods on it, turning the module's conceptual material into working code.

A consolidated reading that compiles all module topics — graph fundamentals, directed versus undirected graphs, adjacency matrices and lists, BFS, DFS, and the JavaScript implementation — into a single document for review or study reference.

An interactive HTML activity in which learners work with a weighted sample graph of six labeled vertices (A–F) and eight edges, exploring adjacency structures and traversing from a start vertex to a finish vertex; it is used for hands-on practice with graph representation and path-finding after the reading.

A hands-on coding reading that walks learners through building a JavaScript Graph class from scratch, then adding BFS and DFS methods step by step, so they can translate traversal concepts into working, runnable code.

This Veritasium video explores the mathematical and algorithmic principles behind how Google Maps computes routes so efficiently. It examines the graph-based representation of road networks and the optimization strategies that make real-time pathfinding feasible at massive scale. The video connects foundational graph theory to a widely recognized, high-impact real-world application.

A self-contained HTML/JavaScript activity presented as a 'field-study board': a weighted graph is displayed as a specimen tray on the left, while the right-hand column holds a token pile and a live readout showing current cost, best-known cost, the route taken, and a step log. Students place tokens along edges to build a route through the graph while the on-screen 'bug' tracks and reports path cost, competing routes, and the final result. The interface is fully responsive, keyboard-focusable, and includes light/dark theming for accessibility.