1Graph:
2    5 → 2 → 3
3    5 → 0
4    4 → 0
5    4 → 1
6    2 → 3 → 1
7
8DFS from node 5, then 4:
9Postorder:         [3, 1, 2, 0, 5, 4]  (nodes in order of DFS completion)
10Reverse Postorder: [4, 5, 0, 2, 1, 3]  (reversed — parents before children)

1def reverse_postorder(graph):
2    """Return nodes in reverse postorder (topological order for DAGs)."""
3    visited = set()
4    postorder = []
5
6    def dfs(node):
7        visited.add(node)
8        for neighbor in graph.get(node, []):
9            if neighbor not in visited:
10                dfs(neighbor)
11        postorder.append(node)  # add AFTER visiting all descendants
12
13    # Visit all nodes (handles disconnected graphs)
14    for node in graph:
15        if node not in visited:
16            dfs(node)
17
18    # Reverse the postorder
19    return postorder[::-1]
20
21# Example graph (adjacency list)
22graph = {
23    5: [2, 0],
24    4: [0, 1],
25    2: [3],
26    3: [1],
27    0: [],
28    1: [],
29}
30
31result = reverse_postorder(graph)
32print(result)  # [4, 5, 0, 2, 3, 1] or another valid topological order

1def reverse_postorder_iterative(graph):
2    """Iterative DFS to compute reverse postorder."""
3    visited = set()
4    postorder = []
5
6    for start in graph:
7        if start in visited:
8            continue
9        stack = [(start, False)]
10        while stack:
11            node, processed = stack.pop()
12            if processed:
13                postorder.append(node)
14                continue
15            if node in visited:
16                continue
17            visited.add(node)
18            # Push the node again with processed=True for postorder recording
19            stack.append((node, True))
20            # Push neighbors in reverse order for consistent traversal
21            for neighbor in reversed(graph.get(node, [])):
22                if neighbor not in visited:
23                    stack.append((neighbor, False))
24
25    return postorder[::-1]

1class TreeNode:
2    def __init__(self, val, left=None, right=None):
3        self.val = val
4        self.left = left
5        self.right = right
6
7def tree_postorder(root):
8    """Postorder: left, right, root."""
9    if root is None:
10        return []
11    return (tree_postorder(root.left) +
12            tree_postorder(root.right) +
13            [root.val])
14
15def tree_reverse_postorder(root):
16    """Reverse postorder: root, right, left (reversed)."""
17    return tree_postorder(root)[::-1]
18
19#       1
20#      / \
21#     2   3
22#    / \
23#   4   5
24
25root = TreeNode(1,
26    TreeNode(2, TreeNode(4), TreeNode(5)),
27    TreeNode(3)
28)
29
30print(tree_postorder(root))          # [4, 5, 2, 3, 1]
31print(tree_reverse_postorder(root))  # [1, 3, 2, 5, 4]

1# Reverse postorder IS topological order for DAGs
2
3# Dependency graph: task A must finish before task B
4dependencies = {
5    "compile":  ["link"],
6    "test":     [],
7    "link":     ["test"],
8    "package":  [],
9    "deploy":   ["package"],
10    "build":    ["compile", "test"],
11}
12
13order = reverse_postorder(dependencies)
14print(order)
15# ['build', 'compile', 'link', 'test', 'deploy', 'package']
16# or another valid topological ordering

1// Compiler data flow analysis uses reverse postorder for:
2
3// 1. Reaching definitions: propagate variable definitions forward
4// 2. Live variable analysis: propagate variable uses backward
5// 3. Constant propagation: substitute known constants
6// 4. SSA construction: place phi functions at dominance frontiers
7
8// Processing basic blocks in reverse postorder ensures that
9// (for forward analyses) all predecessors of a block are
10// processed before the block itself, leading to faster convergence.
11
12// Control Flow Graph:
13//   Entry → B1 → B2 → B3 → Exit
14//               ↘ B4 ↗
15//
16// Reverse Postorder: [Entry, B1, B2, B4, B3, Exit]
17// Processing in this order means B1's results are ready when B2 is processed

1graph = {0: [1, 2], 1: [3], 2: [3], 3: []}
2
3# Preorder (DFS): record when first visited
4# [0, 1, 3, 2]
5
6# Postorder (DFS): record when DFS backtracks
7# [3, 1, 2, 0]
8
9# Reverse Postorder: reversed postorder
10# [0, 2, 1, 3]
11
12# BFS Level Order:
13# [0, 1, 2, 3]