Adjacency List Representation in DSA Typescript

Mental Model

We store each node and a list of its neighbors to show connections in a graph.

Analogy: Imagine a group of friends where each person keeps a list of their friends' names. This way, you know who is connected to whom by looking at each person's list.

Node 0 -> [1, 2]
Node 1 -> [0, 3]
Node 2 -> [0]
Node 3 -> [1]

Dry Run Walkthrough

Input: Graph with edges: 0-1, 0-2, 1-3

Goal: Build adjacency lists showing neighbors for each node

Step 1: Add edge 0-1: add 1 to node 0's list and 0 to node 1's list

Node 0 -> [1]
Node 1 -> [0]
Node 2 -> []
Node 3 -> []

Why: We record that node 0 and node 1 are connected

Step 2: Add edge 0-2: add 2 to node 0's list and 0 to node 2's list

Node 0 -> [1, 2]
Node 1 -> [0]
Node 2 -> [0]
Node 3 -> []

Why: We record that node 0 and node 2 are connected

Step 3: Add edge 1-3: add 3 to node 1's list and 1 to node 3's list

Node 0 -> [1, 2]
Node 1 -> [0, 3]
Node 2 -> [0]
Node 3 -> [1]

Why: We record that node 1 and node 3 are connected

Result:

Node 0 -> [1, 2]
Node 1 -> [0, 3]
Node 2 -> [0]
Node 3 -> [1]

Annotated Code

DSA Typescript

class Graph {
  adjacencyList: Map<number, number[]>;

  constructor(nodes: number) {
    this.adjacencyList = new Map();
    for (let i = 0; i < nodes; i++) {
      this.adjacencyList.set(i, []);
    }
  }

  addEdge(u: number, v: number): void {
    this.adjacencyList.get(u)?.push(v); // add v to u's neighbors
    this.adjacencyList.get(v)?.push(u); // add u to v's neighbors
  }

  printGraph(): void {
    for (const [node, neighbors] of this.adjacencyList.entries()) {
      console.log(`Node ${node} -> [${neighbors.join(", ")}]`);
    }
  }
}

// Driver code
const graph = new Graph(4);
graph.addEdge(0, 1);
graph.addEdge(0, 2);
graph.addEdge(1, 3);
graph.printGraph();

this.adjacencyList.set(i, []);

Initialize empty neighbor list for each node

this.adjacencyList.get(u)?.push(v);

Add v to u's neighbor list to record edge

this.adjacencyList.get(v)?.push(u);

Add u to v's neighbor list to record edge (undirected graph)

for (const [node, neighbors] of this.adjacencyList.entries()) {

Iterate over all nodes to print their neighbors

Output

Node 0 -> [1, 2]

Node 1 -> [0, 3]

Node 2 -> [0]

Node 3 -> [1]

Complexity Analysis

Time: O(V + E) because we initialize all nodes and add each edge once

Space: O(V + E) because we store a list of neighbors for each node and each edge twice

vs Alternative: Compared to adjacency matrix which uses O(V^2) space, adjacency list is more efficient for sparse graphs

Edge Cases

Graph with no edges

All nodes have empty neighbor lists

DSA Typescript

this.adjacencyList.set(i, []);

Graph with single node

One node with empty neighbor list

DSA Typescript

this.adjacencyList.set(i, []);

Adding edge with invalid node index

No neighbors added because get returns undefined and optional chaining prevents error

DSA Typescript

this.adjacencyList.get(u)?.push(v);

When to Use This Pattern

When you need to represent graph connections efficiently and want to quickly find neighbors of a node, use adjacency list representation because it stores only existing edges.

Common Mistakes

Mistake: Forgetting to add the edge in both directions for undirected graphs
Fix: Add neighbors to both nodes' lists to represent undirected edges

Summary

Stores each node with a list of its connected neighbors to represent a graph.

Use when you want efficient storage and quick access to neighbors in sparse graphs.

The key is each node keeps its own list of neighbors, so you only store actual connections.

Practice

1. What does an adjacency list represent in graph data structures?

easy

A. A list of all nodes without connections

B. A matrix showing distances between nodes

C. A queue of nodes to visit next

D. A list where each node stores its connected neighbors

Solution

1. Step 1: Understand adjacency list concept

   An adjacency list stores each node with a list of its neighbors, showing direct connections.

2. Step 2: Compare options with definition

   Only A list where each node stores its connected neighbors correctly describes this structure; others describe different concepts.

3. Final Answer:

   A list where each node stores its connected neighbors -> Option D

4. Quick Check:

   Adjacency list = neighbors list [OK]

Hint: Adjacency list always stores neighbors per node [OK]

Common Mistakes:

• Confusing adjacency list with adjacency matrix
• Thinking it stores distances instead of neighbors
• Assuming it is a queue or unrelated structure

2. Which of the following is the correct TypeScript syntax to declare an adjacency list for a graph with nodes as numbers?

easy

A. const graph: number[][] = [];

B. const graph: Map = new Map();

C. const graph: Record = {};

D. const graph: Array<number> = [];

Solution

1. Step 1: Identify adjacency list type

   An adjacency list maps each node (number) to an array of connected nodes (number[]).

2. Step 2: Match TypeScript syntax

   Map correctly represents this; others are incorrect types or structures.

3. Final Answer:

   const graph: Map = new Map(); -> Option B

4. Quick Check:

   Map = adjacency list [OK]

Hint: Use Map with number keys and array values for adjacency list [OK]

Common Mistakes:

• Using Record which maps to single number, not array
• Using number[][] without keys for nodes
• Using Array<number> which is just a list, not adjacency

3. Given the following TypeScript code, what is the output after adding edges?

const graph: Map = new Map();
graph.set(1, [2, 3]);
graph.set(2, [1]);
graph.set(3, [1, 4]);
graph.set(4, [3]);
console.log(graph.get(3));

medium

A. [2, 3]

B. [3, 4]

C. [1, 4]

D. undefined

Solution

1. Step 1: Trace graph.set calls

   Node 3 is set with neighbors [1, 4].

2. Step 2: Check graph.get(3)

   Returns the array [1, 4] assigned to node 3.

3. Final Answer:

   [1, 4] -> Option C

4. Quick Check:

   graph.get(3) = [1, 4] [OK]

Hint: graph.get(node) returns neighbors array [OK]

Common Mistakes:

• Confusing neighbors of node 3 with node 1 or 2
• Expecting undefined if not careful with set calls
• Mixing up array contents order

4. Identify the error in this TypeScript adjacency list code snippet:

const graph: Map = new Map();
graph.set(1, [2]);
graph.set(2, [1]);
graph.get(3).push(1);

medium

A. graph.get(3) returns undefined, so push causes error

B. Map keys must be strings, not numbers

C. graph.set should use arrays of strings, not numbers

D. Missing initialization of graph variable

Solution

1. Step 1: Check graph.get(3) call

   Node 3 was never set, so graph.get(3) returns undefined.

2. Step 2: Understand push on undefined

   Calling push on undefined causes runtime error.

3. Final Answer:

   graph.get(3) returns undefined, so push causes error -> Option A

4. Quick Check:

   Accessing unset key returns undefined [OK]

Hint: Check if key exists before pushing to adjacency list [OK]

Common Mistakes:

• Assuming graph.get(3) returns empty array automatically
• Thinking Map keys must be strings (numbers are allowed)
• Ignoring runtime error from push on undefined

5. You want to represent a directed graph with nodes 1 to 4 using an adjacency list in TypeScript. Which code correctly adds an edge from node 2 to node 4 without affecting other edges?

const graph: Map = new Map();
graph.set(1, [2]);
graph.set(2, [3]);
graph.set(3, []);
graph.set(4, []);
// Add edge from 2 to 4 here

hard

A. graph.get(2)?.push(4);

B. graph.set(2, [4]);

C. graph.set(4, [2]);

D. graph.get(4)?.push(2);

Solution

1. Step 1: Understand existing edges

   Node 2 currently has neighbors [3]. We want to add 4 without removing 3.

2. Step 2: Choose correct method to add edge

   Using graph.get(2)?.push(4) adds 4 to existing array, preserving [3]. graph.set(2, [4]) replaces neighbors, removing 3.

3. Final Answer:

   graph.get(2)?.push(4); -> Option A

4. Quick Check:

   Use push to add edge without overwriting [OK]

Hint: Use push on existing neighbors to add edges safely [OK]

Common Mistakes:

• Overwriting neighbors array with set instead of pushing
• Adding edge to wrong node
• Confusing direction of edge in directed graph