Why Graphs Exist and What Trees Cannot Model in DSA Python - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why can't trees model all relationships?

Which of the following is a key reason why trees cannot model all types of relationships that graphs can?

A Trees cannot represent cycles or multiple connections between nodes.

B Trees allow multiple parents for a single node.

C Trees always have disconnected nodes.

D Trees do not have nodes or edges.

💡 Hint

Think about what a tree structure looks like compared to a graph.

Trees are hierarchical and cannot have cycles or nodes with multiple parents, while graphs can represent cycles and complex connections.

❓ Predict Output

intermediate

Output of graph with cycle vs tree

What is the output of the following Python code that tries to represent a cycle using adjacency lists?

DSA Python

graph = { 'A': ['B'], 'B': ['C'], 'C': ['A'] }
print(graph)

A {'A': ['B'], 'B': ['C'], 'C': []}

B SyntaxError

C {'A': ['B'], 'B': ['C'], 'C': ['A']}

D {'A': [], 'B': ['C'], 'C': ['A']}

💡 Hint

Look at how adjacency lists represent edges.

The dictionary shows each node with its connected nodes, including the cycle from C back to A.

❓ Predict Output

advanced

Detecting cycles in a graph

What is the output of the following Python code that tries to detect a cycle in a graph represented as adjacency list?

DSA Python

def has_cycle(graph, node, visited, parent):
    visited.add(node)
    for neighbor in graph[node]:
        if neighbor not in visited:
            if has_cycle(graph, neighbor, visited, node):
                return True
        elif neighbor != parent:
            return True
    return False

graph = {'A': ['B'], 'B': ['C'], 'C': ['A']}
visited = set()
print(has_cycle(graph, 'A', visited, None))

A KeyError

B True

C False

D TypeError

💡 Hint

Trace the recursive calls and check the cycle detection logic.

The function correctly detects the cycle A->B->C->A and returns True.

❓ Predict Output

advanced

Output of graph with multiple parents

What is the output of this adjacency list representing a graph where a node has multiple parents?

DSA Python

graph = {'A': ['C'], 'B': ['C'], 'C': []}
print(graph)

A {'A': ['C'], 'B': ['C'], 'C': []}

B {'A': [], 'B': [], 'C': ['A', 'B']}

C {'A': ['B'], 'B': ['C'], 'C': []}

D SyntaxError

💡 Hint

Check how edges are represented from parents to children.

The graph shows nodes A and B both pointing to C, meaning C has multiple parents.

🧠 Conceptual

expert

Why graphs are essential beyond trees

Which real-life scenario best illustrates why graphs are necessary and trees are insufficient?

A Listing steps in a linear recipe.

B Modeling a family tree where each child has exactly one set of parents.

C Organizing files in a folder hierarchy on a computer.

D Representing a social network where people can have multiple friendships and mutual connections.

💡 Hint

Think about relationships that are not strictly hierarchical.

Social networks have complex, mutual, and multiple connections that trees cannot represent, but graphs can.

Practice

1. Why do we need graphs when we already have trees in data structures?

easy

A. Because graphs use less memory than trees.

B. Because trees are faster to traverse than graphs.

C. Because graphs can represent connections between nodes in any pattern, including cycles and multiple parents.

D. Because trees can only store numbers, but graphs can store any data.

Solution

1. Step 1: Understand tree limitations

   Trees have a strict hierarchy: each node has only one parent and no cycles.

2. Step 2: Understand graph capabilities

   Graphs allow nodes to connect in any way, including cycles and multiple parents.

3. Final Answer:

   Because graphs can represent connections between nodes in any pattern, including cycles and multiple parents. -> Option C

4. Quick Check:

   Graphs model complex connections unlike trees [OK]

Hint: Graphs allow cycles and multiple parents; trees do not [OK]

Common Mistakes:

• Thinking trees can have cycles
• Confusing data types stored with structure type
• Assuming graphs always use less memory

2. Which of the following is the correct way to represent an undirected graph using adjacency lists in Python?

easy

A. graph = [[1, 2], [2, 3], [3, 1]]

B. graph = {1: (2, 3), 2: (1), 3: (1)}

C. graph = {1: 2, 2: 3, 3: 1}

D. graph = {1: [2, 3], 2: [1], 3: [1]}

Solution

1. Step 1: Understand adjacency list format

   Adjacency lists use a dictionary with keys as nodes and values as lists of connected nodes.

2. Step 2: Check each option

   graph = {1: [2, 3], 2: [1], 3: [1]} uses dictionary with lists correctly; others use tuples, lists of pairs, or single values incorrectly.

3. Final Answer:

   graph = {1: [2, 3], 2: [1], 3: [1]} -> Option D

4. Quick Check:

   Adjacency list = dict with lists [OK]

Hint: Adjacency lists use dict keys with list values [OK]

Common Mistakes:

• Using tuples instead of lists for adjacency
• Using list of pairs instead of dict
• Assigning single node instead of list

3. What will be the output of the following Python code that models a graph?

graph = {1: [2, 3], 2: [1, 3], 3: [1, 2]}
print(len(graph[2]))

medium

A. 2

B. 1

C. 3

D. Error

Solution

1. Step 1: Analyze graph dictionary

   Node 2 connects to nodes 1 and 3, so graph[2] = [1, 3].

2. Step 2: Calculate length of adjacency list

   Length of graph[2] is 2 because it has two connected nodes.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   len([1, 3]) = 2 [OK]

Hint: Count connected nodes in adjacency list [OK]

Common Mistakes:

• Counting total nodes instead of neighbors
• Confusing keys with values
• Expecting error due to syntax

4. The following code tries to add an edge between nodes in an undirected graph but has a bug. What is the bug?

graph = {1: [2], 2: [1]}
def add_edge(u, v):
    graph[u].append(v)
    graph[v].append(u)

add_edge(2, 3)
print(graph)

medium

A. Node 3 is not initialized in the graph before adding edges.

B. The append method is used incorrectly.

C. The graph dictionary should use sets instead of lists.

D. The function add_edge should return the graph.

Solution

1. Step 1: Check graph initialization

   Node 3 does not exist in graph keys before add_edge is called.

2. Step 2: Understand append behavior

   Appending to graph[v] fails because graph[3] key is missing, causing KeyError.

3. Final Answer:

   Node 3 is not initialized in the graph before adding edges. -> Option A

4. Quick Check:

   Missing key causes error [OK]

Hint: Initialize nodes before adding edges [OK]

Common Mistakes:

• Assuming append works without key
• Thinking return needed in add_edge
• Confusing list vs set usage

5. Given a tree structure, which of the following scenarios can only be correctly modeled by converting it into a graph?

hard

A. Representing a family tree where each child has exactly one parent.

B. Modeling a social network where users can follow each other mutually or one-way.

C. Storing a file directory where each folder has a single parent folder.

D. Organizing a company's hierarchy with clear reporting lines.

Solution

1. Step 1: Analyze tree modeling scenarios

   Family trees, file directories, and company hierarchies have strict parent-child relations, fitting trees.

2. Step 2: Analyze graph necessity

   Social networks have complex connections, including cycles and mutual or one-way links, needing graphs.

3. Final Answer:

   Modeling a social network where users can follow each other mutually or one-way. -> Option B

4. Quick Check:

   Complex connections need graphs [OK]

Hint: Use graphs for mutual or cyclic connections [OK]

Common Mistakes:

• Thinking family trees need graphs
• Confusing hierarchy with network
• Assuming all parent-child fit graphs only