⚡️ 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.