How do I implement topological sorting in a graph?

What is topological sorting and when is it used?

Topological sorting is an ordering of the vertices in a directed acyclic graph (DAG) such that for every directed edge u -> v, vertex u comes before v. It's commonly used in scheduling tasks, resolving dependencies, and organizing data.

How can I implement topological sorting in Python?

You can implement topological sorting using Depth-First Search (DFS) or Kahn's algorithm. Would you like a code example for one of these methods?

Yes, please provide a code example using DFS.

Here's a simple implementation using DFS:

from collections import defaultdict

class Graph:
    def __init__(self):
        self.graph = defaultdict(list)

    def add_edge(self, u, v):
        self.graph[u].append(v)

    def topological_sort_util(self, v, visited, stack):
        visited.add(v)
        for neighbor in self.graph[v]:
            if neighbor not in visited:
                self.topological_sort_util(neighbor, visited, stack)
        stack.append(v)

    def topological_sort(self):
        visited = set()
        stack = []
        for vertex in self.graph:
            if vertex not in visited:
                self.topological_sort_util(vertex, visited, stack)
        return stack[::-1]  # Return reversed stack

# Example usage:
g = Graph()
g.add_edge(5, 2)
g.add_edge(5, 0)
g.add_edge(4, 0)
g.add_edge(4, 1)
g.add_edge(2, 3)
g.add_edge(3, 1)

print(g.topological_sort())

What are the time and space complexities of this algorithm?

The time complexity of topological sorting using DFS is O(V + E), where V is the number of vertices and E is the number of edges. The space complexity is O(V) for the visited set and the stack.