Adjacency List vs Matrix When to Choose Which in DSA Java - Key Differences

Recall & Review

beginner

What is an adjacency list in graph representation?

An adjacency list stores each vertex and a list of its connected neighbors. It uses less space for sparse graphs and allows efficient traversal of neighbors.

beginner

What is an adjacency matrix in graph representation?

An adjacency matrix is a 2D array where each cell (i, j) indicates if there is an edge between vertex i and vertex j. It uses more space but allows quick edge checks.

intermediate

When is it better to use an adjacency list over an adjacency matrix?

Use an adjacency list when the graph is sparse (few edges) because it saves memory and is faster to iterate neighbors.

intermediate

When is an adjacency matrix preferred over an adjacency list?

Use an adjacency matrix when the graph is dense (many edges) or when you need to quickly check if an edge exists between two vertices.

intermediate

What is the space complexity difference between adjacency list and adjacency matrix?

Adjacency list uses O(V + E) space, where V is vertices and E is edges. Adjacency matrix uses O(V²) space regardless of edges.

Which graph representation is more memory efficient for a graph with 1000 vertices and 10 edges?

A None of the above

B Adjacency Matrix

C Both use the same memory

D Adjacency List

Adjacency list uses memory proportional to vertices plus edges, so it is more efficient for sparse graphs like this.

Which representation allows O(1) time to check if an edge exists between two vertices?

A Adjacency Matrix

B Both have O(1)

C Adjacency List

D Neither

Adjacency matrix stores edges in a 2D array, so checking an edge is a direct index lookup.

For a dense graph, which representation is generally better?

A Either works equally

B Adjacency List

C Adjacency Matrix

D Use edge list instead

Dense graphs have many edges, so adjacency matrix is better for quick edge checks and simpler implementation.

What is the time complexity to iterate all neighbors of a vertex in an adjacency list?

A O(degree of vertex)

B O(V)

C O(E)

D O(1)

Adjacency list stores neighbors directly, so iterating neighbors takes time proportional to the vertex's degree.

Which representation is simpler to implement for small graphs?

A Adjacency List

B Adjacency Matrix

C Both are equally simple

D Neither

Adjacency matrix is simpler because it uses a fixed-size 2D array and direct indexing.

Explain when you would choose an adjacency list over an adjacency matrix for graph representation.

Think about how many edges the graph has compared to vertices.

Describe the advantages and disadvantages of using an adjacency matrix.

Consider space and time trade-offs.

Practice

1. Which data structure is generally better for representing a graph with many vertices but very few edges?

easy

A. Adjacency List

B. Adjacency Matrix

C. Array

D. Linked List

Solution

1. Step 1: Understand graph density

   A graph with many vertices but few edges is called a sparse graph.

2. Step 2: Choose efficient representation for sparse graphs

   Adjacency List stores only existing edges, saving space for sparse graphs.

3. Final Answer:

   Adjacency List -> Option A

4. Quick Check:

   Sparse graph = Adjacency List [OK]

Hint: Sparse graph? Use adjacency list for space efficiency [OK]

Common Mistakes:

• Choosing adjacency matrix for sparse graphs wastes space
• Confusing adjacency list with linked list
• Ignoring graph density when choosing representation

2. Which of the following is the correct way to declare an adjacency matrix for a graph with 4 vertices in Java?

easy

A. int[][] adjMatrix = new int[4][4];

B. int adjMatrix = new int[4][4];

C. int[] adjMatrix = new int[4];

D. int[][] adjMatrix = new int[4];

Solution

1. Step 1: Understand adjacency matrix structure

   An adjacency matrix for 4 vertices is a 4x4 2D array.

2. Step 2: Check Java syntax for 2D arrays

   Correct declaration uses int[][] with new int[4][4].

3. Final Answer:

   int[][] adjMatrix = new int[4][4]; -> Option A

4. Quick Check:

   2D array syntax = int[][] adjMatrix = new int[4][4]; [OK]

Hint: Adjacency matrix needs 2D array: int[][] arr = new int[n][n]; [OK]

Common Mistakes:

• Using single brackets for 2D array
• Missing array type brackets
• Declaring as single dimension array

3. Consider the following Java code snippet for an undirected graph with 3 vertices:

int[][] matrix = new int[3][3];
matrix[0][1] = 1;
matrix[1][0] = 1;
matrix[1][2] = 1;
matrix[2][1] = 1;
System.out.println(matrix[0][2]);

What is the output?

medium

A. 1

B. null

C. ArrayIndexOutOfBoundsException

D. 0

Solution

1. Step 1: Analyze matrix initialization and assignments

   Matrix is 3x3 initialized with zeros. Edges set between 0-1 and 1-2.

2. Step 2: Check value at matrix[0][2]

   No edge assigned between 0 and 2, so matrix[0][2] remains 0.

3. Final Answer:

   0 -> Option D

4. Quick Check:

   matrix[0][2] = 0 (no edge) [OK]

Hint: Unassigned edges in matrix default to 0 [OK]

Common Mistakes:

• Assuming symmetric edges without assignment
• Expecting 1 for indirect connections
• Confusing output with exceptions

4. The following code attempts to add an edge in an adjacency list representation for a graph with 3 vertices:

List<Integer>[] adjList = new ArrayList[3];
adjList[0].add(1);

What is the error and how to fix it?

medium

A. No error; code runs fine

B. NullPointerException; initialize each list before adding

C. SyntaxError; use curly braces instead of brackets

D. ArrayIndexOutOfBoundsException; increase array size

Solution

1. Step 1: Identify cause of NullPointerException

   Array created but each element is null; no ArrayList objects initialized.

2. Step 2: Fix by initializing each list

   Use a loop to assign new ArrayList() to each adjList[i] before adding edges.

3. Final Answer:

   NullPointerException; initialize each list before adding -> Option B

4. Quick Check:

   NullPointerException = uninitialized lists [OK]

Hint: Initialize each list in array before adding elements [OK]

Common Mistakes:

• Forgetting to create ArrayList objects
• Assuming array creation initializes lists
• Ignoring runtime exceptions

5. You have a graph with 1000 vertices and about 10,000 edges. You need to perform frequent edge existence checks between any two vertices. Which representation is best and why?

hard

A. Adjacency Matrix, because it uses less space for sparse graphs

B. Adjacency List, because it uses less space and edge checks are O(1)

C. Adjacency Matrix, because it allows O(1) edge checks despite higher space

D. Adjacency List, because it allows O(1) edge checks for dense graphs

Solution

1. Step 1: Analyze graph density

   1000 vertices and 10,000 edges means graph is sparse (max edges ~ 499,500).

2. Step 2: Consider edge existence check speed

   Adjacency matrix allows O(1) edge existence check by direct index access.

3. Step 3: Balance space vs speed

   Though matrix uses more space, frequent edge checks favor adjacency matrix for speed.

4. Final Answer:

   Adjacency Matrix, because it allows O(1) edge checks despite higher space -> Option C

5. Quick Check:

   Frequent edge checks = adjacency matrix [OK]

Hint: Frequent edge checks? Use adjacency matrix for O(1) lookup [OK]

Common Mistakes:

• Choosing adjacency list for O(1) edge checks (it's O(k))
• Ignoring space vs time tradeoff
• Confusing sparse and dense graph definitions