Why Graphs Exist and What Trees Cannot Model in DSA Python - See It Work

Why Graphs Exist and What Trees Cannot Model

📖 Scenario: Imagine you are organizing a group of friends and their connections. Some friends know each other directly, and some are connected through others. You want to represent these connections to understand who is connected to whom.Trees are like family trees where each person has only one parent, but in real life, friends can have many connections in different ways. This is why graphs exist -- to model complex connections that trees cannot.

🎯 Goal: You will create a simple graph using a dictionary to represent friends and their connections. You will see how this graph can model relationships that a tree cannot.

📋 What You'll Learn

Create a dictionary called friend_graph with specific friend connections

Add a variable called new_friend to represent a new friend

Add a new connection between new_friend and an existing friend

Print the updated friend_graph to see all connections

💡 Why This Matters

🌍 Real World

Graphs are used to model social networks, maps, and many real-world connections where relationships are not just one-to-one.

💼 Career

Understanding graphs is important for jobs in software development, data science, and network analysis where complex relationships need to be modeled.

1

Create the initial friend graph

Create a dictionary called friend_graph with these exact entries: 'Alice': ['Bob', 'Charlie'], 'Bob': ['Alice', 'David'], 'Charlie': ['Alice'], 'David': ['Bob']

DSA Python

# Create the friend_graph dictionary with given connections
# Your code here

Hint

Use a dictionary with friend names as keys and lists of connected friends as values.

2

Add a new friend variable

Add a variable called new_friend and set it to the string 'Eve'

DSA Python

friend_graph = {
    'Alice': ['Bob', 'Charlie'],
    'Bob': ['Alice', 'David'],
    'Charlie': ['Alice'],
    'David': ['Bob']
}
# Add the new_friend variable
# Your code here

Hint

Just create a variable named new_friend and assign it the value 'Eve'.

3

Add a new connection in the graph

Add new_friend as a key in friend_graph with a list containing 'Alice'. Also, add new_friend to 'Alice''s list of connections in friend_graph

DSA Python

friend_graph = {
    'Alice': ['Bob', 'Charlie'],
    'Bob': ['Alice', 'David'],
    'Charlie': ['Alice'],
    'David': ['Bob']
}
new_friend = 'Eve'
# Add new_friend to friend_graph and connect with 'Alice'
# Your code here

Hint

Use friend_graph[new_friend] = ['Alice'] to add Eve, and friend_graph['Alice'].append(new_friend) to connect Alice back to Eve.

4

Print the updated friend graph

Print the friend_graph dictionary to show all friend connections

DSA Python

friend_graph = {
    'Alice': ['Bob', 'Charlie'],
    'Bob': ['Alice', 'David'],
    'Charlie': ['Alice'],
    'David': ['Bob']
}
new_friend = 'Eve'
friend_graph[new_friend] = ['Alice']
friend_graph['Alice'].append(new_friend)
# Print the friend_graph
# Your code here

Hint

Use print(friend_graph) to display the dictionary.

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