Adjacency List vs Matrix When to Choose Which in DSA Java - Interactive Comparison Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an adjacency matrix for a graph with 5 nodes.

DSA Java

int[][] adjacencyMatrix = new int[[1]][[1]];

Drag options to blanks, or click blank then click option'

A5

B10

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using total edges instead of nodes for matrix size

Using zero or one instead of number of nodes

The adjacency matrix size is n x n, where n is the number of nodes. For 5 nodes, it is 5x5.

2fill in blank

medium

Complete the code to add an edge from node 2 to node 4 in an adjacency list representation.

DSA Java

adjacencyList.get([1]).add(4);

Drag options to blanks, or click blank then click option'

A3

B1

C2

D4

Attempts:

3 left

💡 Hint

Common Mistakes

Using the destination node index instead of source

Off-by-one errors in indexing

Node indices start at 0 or 1 depending on implementation. Here, adding edge from node 2 means accessing index 2.

3fill in blank

hard

Fix the error in the code that checks if an edge exists between node 1 and node 3 using adjacency matrix.

DSA Java

if (adjacencyMatrix[1][[1]] == 1) { System.out.println("Edge exists"); }

Drag options to blanks, or click blank then click option'

A3

B2

C1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong destination index

Confusing source and destination indices

To check edge from node 1 to node 3, use adjacencyMatrix[1][3].

4fill in blank

hard

Fill both blanks to create an adjacency list for a graph with 4 nodes and add an edge from node 0 to node 2.

DSA Java

List<List<Integer>> adjacencyList = new ArrayList<>();
for (int i = 0; i < [1]; i++) {
    adjacencyList.add(new [2]<>());
}
adjacencyList.get(0).add(2);

Drag options to blanks, or click blank then click option'

A4

BLinkedList

CArrayList

DHashSet

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong number of nodes

Using wrong list type

We create 4 lists for 4 nodes. ArrayList is a common choice for adjacency lists.

5fill in blank

hard

Fill all three blanks to check if an edge exists from node 3 to node 1 in an adjacency list and print a message.

DSA Java

if (adjacencyList.get([1]).[2]([3])) {
    System.out.println("Edge exists from 3 to 1");
}

Drag options to blanks, or click blank then click option'

A3

Bcontains

C1

Dadd

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong method like add instead of contains

Using wrong indices

To check edge from node 3 to 1, get list at index 3 and check if it contains 1.

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