Topological Sort Using DFS in DSA Python - Build from Scratch

Topological Sort Using DFS

📖 Scenario: Imagine you are managing tasks in a project where some tasks must be done before others. You want to find an order to do all tasks so that every task is done only after all its prerequisites are completed.

🎯 Goal: Build a program that uses Depth-First Search (DFS) to perform a topological sort on a directed graph representing task dependencies. The output will show the order in which tasks should be completed.

📋 What You'll Learn

Create a directed graph using a dictionary where keys are task names and values are lists of dependent tasks.

Use a helper set to track visited tasks during DFS.

Implement DFS to explore tasks and build the topological order.

Print the final topological order of tasks.

💡 Why This Matters

🌍 Real World

Topological sorting is used in project management, build systems, and scheduling where some tasks must happen before others.

💼 Career

Understanding topological sort and DFS is important for software engineers working on dependency resolution, task scheduling, and compiler design.

1

Create the task dependency graph

Create a dictionary called graph with these exact entries: 'Cook': ['Eat'], 'Shop': ['Cook'], 'Clean': ['Cook'], 'Eat': []

DSA Python

# Create the graph dictionary with the given tasks and dependencies
# Your code here

Hint

Think of each task as a key, and the tasks that depend on it as the list of values.

2

Create a set to track visited tasks

Create an empty set called visited to keep track of tasks you have already checked during DFS

DSA Python

graph = {
    'Cook': ['Eat'],
    'Shop': ['Cook'],
    'Clean': ['Cook'],
    'Eat': []
}
# Create an empty set called visited
# Your code here

Hint

A set is perfect to remember which tasks you have already visited.

3

Implement DFS function for topological sort

Define a function called dfs that takes a task and a stack list. Inside, add task to visited, then for each neighbor in graph[task], if neighbor is not in visited, call dfs(neighbor, stack). After visiting neighbors, append task to stack. Then create an empty list stack and for each task in graph, if task is not in visited, call dfs(task, stack)

DSA Python

graph = {
    'Cook': ['Eat'],
    'Shop': ['Cook'],
    'Clean': ['Cook'],
    'Eat': []
}
visited = set()
# Define dfs function and run it for all tasks
# Your code here

Hint

DFS visits all dependent tasks before adding the current task to the stack.

4

Print the topological order

Print the list stack reversed using print(stack[::-1]) to show the correct order of tasks

DSA Python

graph = {
    'Cook': ['Eat'],
    'Shop': ['Cook'],
    'Clean': ['Cook'],
    'Eat': []
}
visited = set()

def dfs(task, stack):
    visited.add(task)
    for neighbor in graph[task]:
        if neighbor not in visited:
            dfs(neighbor, stack)
    stack.append(task)

stack = []
for task in graph:
    if task not in visited:
        dfs(task, stack)

# Print the topological order by reversing stack
# Your code here

Hint

Reversing the stack gives the correct order to complete tasks.

Practice

1. What is the main purpose of using DFS in Topological Sort on a directed graph?

easy

A. To visit nodes in a way that all dependencies come before the node itself

B. To find the shortest path between two nodes

C. To detect cycles in an undirected graph

D. To count the number of connected components

Solution

1. Step 1: Understand DFS role in Topological Sort

   DFS visits nodes deeply, ensuring all nodes reachable from a node are visited before the node itself.

2. Step 2: Relate DFS order to dependencies

   In Topological Sort, this means all dependencies (nodes with edges to current node) are processed before the node, preserving order.

3. Final Answer:

   To visit nodes in a way that all dependencies come before the node itself -> Option A

4. Quick Check:

   DFS ensures dependency order in Topological Sort [OK]

Hint: DFS visits dependencies before the node itself [OK]

Common Mistakes:

• Confusing DFS with BFS for topological order
• Thinking DFS finds shortest paths here
• Mixing cycle detection with topological sorting

2. Which of the following is the correct way to mark a node as visited in a DFS-based topological sort in Python?

easy

A. visited.add(node)

B. visited[node] == True

C. visited[node] = True

D. visited.append(node)

Solution

1. Step 1: Understand visited data structure type

   Usually, visited is a list or dictionary indexed by node, so marking visited means assigning True to that index.

2. Step 2: Identify correct syntax for assignment

   Using visited[node] = True correctly marks the node as visited. Using '==' is a comparison, not assignment.

3. Final Answer:

   visited[node] = True -> Option C

4. Quick Check:

   Assign True to visited[node] to mark visited [OK]

Hint: Use assignment (=), not comparison (==), to mark visited [OK]

Common Mistakes:

• Using '==' instead of '=' for assignment
• Using visited.append(node) when visited is a dict/list
• Using visited.add(node) when visited is not a set

3. What is the output of the following code snippet for topological sort using DFS?

graph = {0: [1, 2], 1: [2], 2: []}
visited = [False, False, False]
stack = []
def dfs(node):
    visited[node] = True
    for neighbor in graph[node]:
        if not visited[neighbor]:
            dfs(neighbor)
    stack.append(node)

for v in range(3):
    if not visited[v]:
        dfs(v)
print(stack[::-1])

medium

A. [0, 1, 2]

B. [2, 1, 0]

C. [1, 0, 2]

D. [2, 0, 1]

Solution

1. Step 1: Trace DFS calls and stack appends

   Start with node 0: visit 0, then neighbors 1 and 2. DFS(1) visits 1, then 2. DFS(2) visits 2, appends 2. Then append 1, then append 0.

2. Step 2: Reverse stack to get topological order

   Stack after DFS: [2, 1, 0]. Reversing gives [0, 1, 2].

3. Final Answer:

   [0, 1, 2] -> Option A

4. Quick Check:

   Stack reversed gives correct topological order [OK]

Hint: Reverse stack after DFS to get topological order [OK]

Common Mistakes:

• Not reversing the stack before printing
• Appending nodes before recursive DFS calls
• Confusing order of neighbors visited

4. Identify the error in this DFS-based topological sort code snippet:

def dfs(node):
    visited[node] = True
    for neighbor in graph[node]:
        if visited[neighbor]:
            dfs(neighbor)
    stack.append(node)

medium

A. DFS should not append nodes to stack

B. Stack should be cleared before DFS

C. Visited should be a set, not a list

D. The condition should be 'if not visited[neighbor]' before calling dfs

Solution

1. Step 1: Analyze the if condition in DFS

   The code calls dfs(neighbor) only if visited[neighbor] is True, which means neighbor was already visited. This causes repeated visits or infinite recursion.

2. Step 2: Correct the condition to avoid revisiting

   The condition should be 'if not visited[neighbor]' to visit unvisited neighbors only.

3. Final Answer:

   The condition should be 'if not visited[neighbor]' before calling dfs -> Option D

4. Quick Check:

   Visit neighbors only if not visited [OK]

Hint: Call dfs only on unvisited neighbors [OK]

Common Mistakes:

• Calling dfs on already visited nodes
• Not marking nodes visited before recursion
• Appending nodes to stack too early

5. Given a directed acyclic graph with edges: 5->2, 5->0, 4->0, 4->1, 2->3, 3->1, which of the following is a valid topological order using DFS-based topological sort?

hard

A. [1, 3, 2, 4, 5, 0]

B. [5, 4, 2, 3, 1, 0]

C. [0, 1, 2, 3, 4, 5]

D. [5, 2, 3, 1, 0, 4]

Solution

1. Step 1: Understand dependencies from edges

   Edges mean 5 before 2 and 0, 4 before 0 and 1, 2 before 3, 3 before 1. So 5 and 4 come before 2,3,1,0.

2. Step 2: Check each option for order validity

   [5, 4, 2, 3, 1, 0] respects all edges: 5 before 2 and 0, 4 before 0 and 1, 2 before 3, 3 before 1. Others violate these orders.

3. Final Answer:

   [5, 4, 2, 3, 1, 0] -> Option B

4. Quick Check:

   All edges respected in order [OK]

Hint: Check all edges respected in order for valid topological sort [OK]

Common Mistakes:

• Ignoring edge directions in order
• Assuming any order of nodes is valid
• Not verifying all dependencies before nodes