⚡️ Speed up method Graph.topologicalSort by 140%

[codeflash-ai]

📄 140% (1.40x) speedup for Graph.topologicalSort in code_to_optimize/topological_sort.py

⏱️ Runtime : 2.67 milliseconds → 1.11 milliseconds (best of 13 runs)

📝 Explanation and details

The optimized code achieves a 140% speedup by replacing an inefficient list operation with a more performant approach. The key optimization is changing stack.insert(0, v) to stack.append(v) followed by a single stack.reverse() call.

What changed:

• In topologicalSortUtil: stack.insert(0, v) → stack.append(v)
• In topologicalSort: Added stack.reverse() before returning
• Minor improvement: visited[i] == False → not visited[i] (slightly more Pythonic)

Why this is faster:
The original code performs stack.insert(0, v) for every node visited, which is an O(N) operation since Python lists must shift all existing elements when inserting at the head. For a graph with N nodes, this results in O(N²) total time complexity just for list operations.

The optimized version uses stack.append(v) (O(1) operation) for each node, then performs a single stack.reverse() (O(N)) at the end. This reduces the list operation complexity from O(N²) to O(N).

Performance impact:
The line profiler shows the stack operation time dropped from 3.06ms (21% of total time) to 1.78ms (12.6% of total time) in topologicalSortUtil. The optimization is particularly effective for larger graphs - test cases show 157-197% speedup for graphs with 1000 nodes, while smaller graphs (≤5 nodes) show minimal or mixed results since the O(N²) vs O(N) difference isn't significant at small scales.

This optimization maintains identical functionality and correctness while dramatically improving performance for larger topological sorting workloads.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 89 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 2 Passed
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

import uuid
from collections import defaultdict

# imports
import pytest
from code_to_optimize.topological_sort import Graph

# unit tests

# ----------- BASIC TEST CASES -----------

def test_empty_graph():
    # Edge: Empty graph (0 vertices)
    g = Graph(0)
    result, sort_id = g.topologicalSort() # 5.25μs -> 5.33μs (1.56% slower)

def test_single_node_graph():
    # Basic: Single node, no edges
    g = Graph(1)
    result, sort_id = g.topologicalSort() # 5.50μs -> 5.62μs (2.22% slower)

def test_two_nodes_no_edges():
    # Basic: Two nodes, no edges
    g = Graph(2)
    result, sort_id = g.topologicalSort() # 5.92μs -> 5.67μs (4.41% faster)

def test_two_nodes_one_edge():
    # Basic: Two nodes, one edge 0->1
    g = Graph(2)
    g.graph[0].append(1)
    result, sort_id = g.topologicalSort() # 5.50μs -> 5.33μs (3.13% faster)

def test_three_nodes_linear():
    # Basic: Linear chain 0->1->2
    g = Graph(3)
    g.graph[0].append(1)
    g.graph[1].append(2)
    result, sort_id = g.topologicalSort() # 5.54μs -> 5.46μs (1.52% faster)

def test_three_nodes_branching():
    # Basic: Branching 0->1, 0->2
    g = Graph(3)
    g.graph[0].append(1)
    g.graph[0].append(2)
    result, sort_id = g.topologicalSort() # 5.38μs -> 5.58μs (3.73% slower)

def test_three_nodes_diamond():
    # Basic: Diamond 0->1, 0->2, 1->2
    g = Graph(3)
    g.graph[0].append(1)
    g.graph[0].append(2)
    g.graph[1].append(2)
    result, sort_id = g.topologicalSort() # 5.42μs -> 5.17μs (4.84% faster)

def test_disconnected_components():
    # Basic: Two disconnected chains: 0->1, 2->3
    g = Graph(4)
    g.graph[0].append(1)
    g.graph[2].append(3)
    result, sort_id = g.topologicalSort() # 5.42μs -> 5.42μs (0.018% faster)

# ----------- EDGE TEST CASES -----------

def test_cycle_detection():
    # Edge: Graph with a cycle (should not be a valid topological sort)
    # The provided implementation does not detect cycles, so it will return a result
    # We check that the output does not satisfy topological sort constraints for a cycle
    g = Graph(3)
    g.graph[0].append(1)
    g.graph[1].append(2)
    g.graph[2].append(0)
    result, sort_id = g.topologicalSort() # 5.12μs -> 5.17μs (0.813% slower)
    # For a cycle, no valid topological sort exists. The output will be some permutation.
    # We check that at least one dependency is violated
    # 0->1, so 0 before 1; 1->2, so 1 before 2; 2->0, so 2 before 0
    # This is impossible; so at least one constraint must be violated.
    violations = 0
    if result.index(0) > result.index(1): violations += 1
    if result.index(1) > result.index(2): violations += 1
    if result.index(2) > result.index(0): violations += 1

def test_self_loop():
    # Edge: Node with a self-loop
    g = Graph(1)
    g.graph[0].append(0)
    result, sort_id = g.topologicalSort() # 4.62μs -> 4.79μs (3.46% slower)

def test_multiple_edges():
    # Edge: Multiple edges between same nodes
    g = Graph(3)
    g.graph[0].append(1)
    g.graph[0].append(1)
    g.graph[1].append(2)
    g.graph[1].append(2)
    result, sort_id = g.topologicalSort() # 5.08μs -> 5.12μs (0.820% slower)

def test_isolated_nodes():
    # Edge: Some nodes have no edges
    g = Graph(4)
    g.graph[0].append(1)
    # nodes 2 and 3 are isolated
    result, sort_id = g.topologicalSort() # 5.29μs -> 5.29μs (0.000% faster)

def test_reverse_edges():
    # Edge: All edges reversed (2->1, 1->0)
    g = Graph(3)
    g.graph[2].append(1)
    g.graph[1].append(0)
    result, sort_id = g.topologicalSort() # 4.96μs -> 5.00μs (0.820% slower)

def test_graph_with_no_edges():
    # Edge: Graph with nodes but no edges
    g = Graph(5)
    result, sort_id = g.topologicalSort() # 5.50μs -> 5.62μs (2.22% slower)

def test_graph_with_duplicate_edges():
    # Edge: Duplicate edges between nodes
    g = Graph(3)
    g.graph[0].extend([1,1,1])
    result, sort_id = g.topologicalSort() # 5.21μs -> 5.17μs (0.813% faster)

def test_large_graph_sparse_edges():
    # Large: 100 nodes, only 1 edge
    g = Graph(100)
    g.graph[0].append(99)
    result, sort_id = g.topologicalSort() # 24.7μs -> 20.9μs (18.1% faster)

# ----------- LARGE SCALE TEST CASES -----------

def test_large_linear_chain():
    # Large: Linear chain of 1000 nodes
    N = 1000
    g = Graph(N)
    for i in range(N-1):
        g.graph[i].append(i+1)
    result, sort_id = g.topologicalSort()

def test_large_branching_tree():
    # Large: Tree structure, 1000 nodes, each node i points to i+1 and i+2 (if possible)
    N = 1000
    g = Graph(N)
    for i in range(N):
        if i+1 < N:
            g.graph[i].append(i+1)
        if i+2 < N:
            g.graph[i].append(i+2)
    result, sort_id = g.topologicalSort()
    # For each i, i before i+1 and i+2
    for i in range(N):
        if i+1 < N:
            pass
        if i+2 < N:
            pass

def test_large_disconnected_graph():
    # Large: 10 chains of 100 nodes each, disconnected
    chains = 10
    chain_len = 100
    N = chains * chain_len
    g = Graph(N)
    for c in range(chains):
        start = c * chain_len
        for i in range(chain_len - 1):
            g.graph[start + i].append(start + i + 1)
    result, sort_id = g.topologicalSort() # 415μs -> 155μs (167% faster)
    # For each chain, order must be preserved
    for c in range(chains):
        start = c * chain_len
        for i in range(chain_len - 1):
            pass

def test_large_graph_all_isolated():
    # Large: 1000 nodes, all isolated
    N = 1000
    g = Graph(N)
    result, sort_id = g.topologicalSort() # 405μs -> 150μs (169% faster)

def test_large_graph_with_cycles():
    # Large: 100 nodes, create a cycle between last three
    N = 100
    g = Graph(N)
    for i in range(N-3):
        g.graph[i].append(i+1)
    # Create cycle: N-3 -> N-2 -> N-1 -> N-3
    g.graph[N-3].append(N-2)
    g.graph[N-2].append(N-1)
    g.graph[N-1].append(N-3)
    result, sort_id = g.topologicalSort() # 25.2μs -> 19.8μs (26.9% faster)
    # At least one constraint must be violated due to cycle
    violations = 0
    if result.index(N-3) > result.index(N-2): violations += 1
    if result.index(N-2) > result.index(N-1): violations += 1
    if result.index(N-1) > result.index(N-3): violations += 1

# ----------- DETERMINISM AND UUID TESTS -----------

def test_uuid_is_unique():
    # Each call should produce a unique uuid string
    g = Graph(1)
    uuid_set = set()
    for _ in range(10):
        _, sort_id = g.topologicalSort() # 29.7μs -> 29.9μs (0.699% slower)
        uuid_set.add(sort_id)

def test_uuid_format():
    # UUID should be a valid string representation
    g = Graph(1)
    _, sort_id = g.topologicalSort() # 4.88μs -> 5.00μs (2.50% slower)
    import re

    # Check for UUID format
    uuid_regex = r'^[a-f0-9\-]{36}

# ----------- RANDOMIZED TEST CASES (DETERMINISTIC) -----------

def test_random_graph_small():
    # Random graph, small size, deterministic edges
    g = Graph(5)
    g.graph[0].append(2)
    g.graph[1].append(2)
    g.graph[2].append(3)
    g.graph[3].append(4)
    result, sort_id = g.topologicalSort() # 5.71μs -> 5.54μs (3.01% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import uuid
from collections import defaultdict

# imports
import pytest  # used for our unit tests
from code_to_optimize.topological_sort import Graph

# unit tests

def is_valid_topo_sort(order, graph_edges, num_vertices):
    """Helper function to check if the returned order is a valid topological sort."""
    position = {node: idx for idx, node in enumerate(order)}
    for u in range(num_vertices):
        for v in graph_edges[u]:
            if position[u] >= position[v]:
                return False
    return set(order) == set(range(num_vertices)) and len(order) == num_vertices

# ------------------------
# 1. Basic Test Cases
# ------------------------

def test_single_node_graph():
    # Graph with a single node and no edges
    g = Graph(1)
    order, sort_id = g.topologicalSort() # 4.96μs -> 4.88μs (1.70% faster)

def test_two_nodes_one_edge():
    # Graph: 0 -> 1
    g = Graph(2)
    g.graph[0].append(1)
    order, sort_id = g.topologicalSort() # 4.96μs -> 4.92μs (0.854% faster)

def test_three_nodes_chain():
    # Graph: 0 -> 1 -> 2
    g = Graph(3)
    g.graph[0].append(1)
    g.graph[1].append(2)
    order, sort_id = g.topologicalSort() # 5.08μs -> 5.04μs (0.813% faster)

def test_three_nodes_branch():
    # Graph: 0 -> 1, 0 -> 2
    g = Graph(3)
    g.graph[0].append(1)
    g.graph[0].append(2)
    order, sort_id = g.topologicalSort() # 5.17μs -> 5.08μs (1.63% faster)

def test_multiple_components():
    # Graph: 0->1, 2->3
    g = Graph(4)
    g.graph[0].append(1)
    g.graph[2].append(3)
    order, sort_id = g.topologicalSort() # 5.21μs -> 5.17μs (0.813% faster)

# ------------------------
# 2. Edge Test Cases
# ------------------------

def test_empty_graph():
    # Empty graph (no nodes)
    g = Graph(0)
    order, sort_id = g.topologicalSort() # 4.25μs -> 4.38μs (2.86% slower)

def test_graph_with_no_edges():
    # Graph with 5 nodes, no edges
    g = Graph(5)
    order, sort_id = g.topologicalSort() # 5.58μs -> 5.46μs (2.31% faster)

def test_graph_with_cycle():
    # Graph: 0->1->2->0 (cycle)
    g = Graph(3)
    g.graph[0].append(1)
    g.graph[1].append(2)
    g.graph[2].append(0)
    # The function does NOT detect cycles, so it will recurse infinitely or stack overflow.
    # We expect a RecursionError or stack overflow.
    with pytest.raises(RecursionError):
        g.topologicalSort()

def test_graph_with_self_loop():
    # Graph: 0->0 (self loop)
    g = Graph(1)
    g.graph[0].append(0)
    with pytest.raises(RecursionError):
        g.topologicalSort()

def test_disconnected_graph():
    # Graph: 0->1, 2, 3 (disconnected nodes)
    g = Graph(4)
    g.graph[0].append(1)
    order, sort_id = g.topologicalSort() # 7.21μs -> 7.79μs (7.48% slower)
    # 2 and 3 can be anywhere

def test_duplicate_edges():
    # Graph: 0->1, 0->1 (duplicate edge)
    g = Graph(2)
    g.graph[0].append(1)
    g.graph[0].append(1)
    order, sort_id = g.topologicalSort() # 6.08μs -> 6.46μs (5.81% slower)

# ------------------------
# 3. Large Scale Test Cases
# ------------------------

def test_large_linear_chain():
    # Graph: 0->1->2->...->999
    n = 1000
    g = Graph(n)
    for i in range(n-1):
        g.graph[i].append(i+1)
    order, sort_id = g.topologicalSort()
    for i in range(n-1):
        pass

def test_large_wide_graph():
    # Graph: 0->i for i=1 to 999
    n = 1000
    g = Graph(n)
    for i in range(1, n):
        g.graph[0].append(i)
    order, sort_id = g.topologicalSort() # 432μs -> 168μs (157% faster)
    # 0 must come before all others
    for i in range(1, n):
        pass

def test_large_sparse_graph():
    # Graph: edges only from even to next odd (0->1, 2->3, ...)
    n = 1000
    g = Graph(n)
    for i in range(0, n-1, 2):
        g.graph[i].append(i+1)
    order, sort_id = g.topologicalSort() # 387μs -> 130μs (197% faster)
    for i in range(0, n-1, 2):
        pass

def test_large_graph_with_multiple_components():
    # Two chains: 0->1->...->499 and 500->501->...->999
    n = 1000
    g = Graph(n)
    for i in range(0, 499):
        g.graph[i].append(i+1)
    for i in range(500, 999):
        g.graph[i].append(i+1)
    order, sort_id = g.topologicalSort() # 404μs -> 141μs (187% faster)
    # Check chains are respected
    for i in range(0, 499):
        pass
    for i in range(500, 999):
        pass

def test_large_graph_with_no_edges():
    # 1000 nodes, no edges
    n = 1000
    g = Graph(n)
    order, sort_id = g.topologicalSort() # 401μs -> 148μs (169% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from code_to_optimize.topological_sort import Graph

def test_Graph_topologicalSort():
    Graph.topologicalSort(Graph(1))

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_7dnvqc5e/tmptwugmlm2/test_concolic_coverage.py::test_Graph_topologicalSort	6.46μs	6.46μs	0.000%✅

To edit these changes git checkout codeflash/optimize-Graph.topologicalSort-mhq0bhxy and push.