⚡️ Speed up function graph_traversal by 916%

[codeflash-ai]

📄 916% (9.16x) speedup for graph_traversal in src/dsa/various.py

⏱️ Runtime : 9.57 milliseconds → 942 microseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 915% speedup by replacing the O(n) list lookup for visited nodes with an O(1) set lookup. The key changes are:

1. Added a dedicated visited set: visited_set = set() for O(1) membership testing
2. Changed lookup operation: if n in visited_set instead of if n in visited
3. Maintained both structures: Added visited_set.add(n) alongside visited.append(n) to preserve the original return format
4. Minor optimization: Changed graph.get(n, []) to graph.get(n, ()) using an empty tuple instead of list

The performance improvement comes from eliminating the expensive O(n) list search operation that occurs on every node visit. In the original code, checking if n in visited requires scanning through the entire visited list, which becomes increasingly expensive as more nodes are traversed.

Test case analysis shows the optimization is most effective for:

• Large dense graphs: 400-2000%+ speedup (complete graphs, binary trees, star topologies)
• Graphs with many nodes: The larger the traversal, the greater the benefit
• Small graphs: Slight overhead (10-15% slower) due to maintaining both data structures

The optimization maintains identical functionality and return values while dramatically improving performance for any graph traversal involving more than a few nodes.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 47 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 1 Passed
🔮 Hypothesis Tests	✅ 100 Passed
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

# imports
import pytest  # used for our unit tests
from src.dsa.various import graph_traversal

# unit tests

# 1. Basic Test Cases

def test_single_node_graph():
    # Graph with one node and no edges
    graph = {1: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.29μs -> 1.46μs (11.5% slower)

def test_two_connected_nodes():
    # Simple graph with two nodes, one edge
    graph = {1: {2: None}, 2: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.58μs -> 1.79μs (11.7% slower)

def test_linear_chain():
    # Linear chain: 1 -> 2 -> 3 -> 4
    graph = {1: {2: None}, 2: {3: None}, 3: {4: None}, 4: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 2.00μs -> 1.96μs (2.15% faster)

def test_simple_cycle():
    # Cycle: 1 -> 2 -> 3 -> 1
    graph = {1: {2: None}, 2: {3: None}, 3: {1: None}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.75μs -> 1.83μs (4.53% slower)

def test_disconnected_graph():
    # Disconnected: 1 -> 2, 3 -> 4
    graph = {1: {2: None}, 2: {}, 3: {4: None}, 4: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.50μs -> 1.50μs (0.000% faster)

def test_starting_from_disconnected_node():
    # Disconnected: 1 -> 2, 3 -> 4, start from 3
    graph = {1: {2: None}, 2: {}, 3: {4: None}, 4: {}}
    codeflash_output = graph_traversal(graph, 3); result = codeflash_output # 1.42μs -> 1.54μs (8.11% slower)

# 2. Edge Test Cases

def test_empty_graph():
    # Empty graph, no nodes
    graph = {}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.12μs -> 1.29μs (12.9% slower)

def test_start_node_not_in_graph():
    # Start node not in graph keys
    graph = {2: {3: None}, 3: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.17μs -> 1.25μs (6.72% slower)

def test_graph_with_isolated_nodes():
    # Graph with isolated nodes
    graph = {1: {}, 2: {}, 3: {}}
    codeflash_output = graph_traversal(graph, 2); result = codeflash_output # 1.04μs -> 1.25μs (16.7% slower)

def test_graph_with_self_loop():
    # Node with a self-loop
    graph = {1: {1: None}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.29μs -> 1.46μs (11.4% slower)

def test_graph_with_multiple_edges():
    # Node with multiple outgoing edges
    graph = {1: {2: None, 3: None}, 2: {}, 3: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.71μs -> 1.71μs (0.000% faster)

def test_graph_with_branching():
    # Branching: 1 -> 2, 1 -> 3, 2 -> 4, 3 -> 5
    graph = {1: {2: None, 3: None}, 2: {4: None}, 3: {5: None}, 4: {}, 5: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 2.25μs -> 2.29μs (1.83% slower)

def test_graph_with_non_integer_nodes():
    # Non-integer nodes (should still work since keys are ints, but let's check)
    graph = {1: {2: None}, 2: {'a': None}, 'a': {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.88μs -> 1.79μs (4.63% faster)

def test_graph_with_empty_neighbors_dict():
    # Graph with empty neighbor dicts
    graph = {1: {}, 2: {}, 3: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.12μs -> 1.21μs (6.95% slower)

def test_graph_with_duplicate_edges():
    # Graph with duplicate edges (should not affect traversal)
    graph = {1: {2: None, 2: None}, 2: {1: None}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.50μs -> 1.71μs (12.2% slower)

# 3. Large Scale Test Cases


def test_large_binary_tree():
    # Large binary tree up to 10 levels (1023 nodes)
    def make_binary_tree(levels):
        graph = {}
        for i in range(1, 2**levels):
            left = 2*i
            right = 2*i + 1
            neighbors = {}
            if left < 2**levels:
                neighbors[left] = None
            if right < 2**levels:
                neighbors[right] = None
            graph[i] = neighbors
        return graph
    graph = make_binary_tree(10)
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 3.85ms -> 180μs (2039% faster)

def test_large_sparse_graph():
    # Large graph with 1000 nodes, only a few edges
    N = 1000
    graph = {i: {} for i in range(1, N+1)}
    # Connect 1 to 2, 2 to 3, ... up to 10
    for i in range(1, 10):
        graph[i][i+1] = None
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 3.58μs -> 3.54μs (1.16% faster)

def test_large_complete_graph():
    # Complete graph of 50 nodes
    N = 50
    graph = {i: {j: None for j in range(1, N+1) if j != i} for i in range(1, N+1)}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 528μs -> 105μs (400% faster)

def test_large_disconnected_graph():
    # 1000 nodes, 10 components of 100 nodes each, start from node 101
    N = 1000
    graph = {}
    for c in range(10):
        base = c*100 + 1
        for i in range(base, base+99):
            graph[i] = {i+1: None}
        graph[base+99] = {}
    codeflash_output = graph_traversal(graph, 101); result = codeflash_output # 59.0μs -> 27.0μs (119% faster)

# Additional edge cases

def test_graph_with_no_edges_and_multiple_nodes():
    # Multiple nodes, no edges
    graph = {i: {} for i in range(1, 10)}
    codeflash_output = graph_traversal(graph, 5); result = codeflash_output # 1.12μs -> 1.25μs (10.0% slower)

def test_graph_with_multiple_cycles():
    # Graph with two cycles sharing a node: 1->2->3->1 and 3->4->5->3
    graph = {1: {2: None}, 2: {3: None}, 3: {1: None, 4: None}, 4: {5: None}, 5: {3: None}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 2.38μs -> 2.38μs (0.000% faster)

def test_graph_with_unreachable_nodes():
    # Unreachable nodes from start
    graph = {1: {2: None}, 2: {}, 3: {4: None}, 4: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.42μs -> 1.54μs (8.05% slower)

def test_graph_with_empty_neighbors():
    # Node with neighbors dict but no neighbors
    graph = {1: {}, 2: {}, 3: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.08μs -> 1.21μs (10.3% slower)

def test_graph_with_large_number_of_edges():
    # 100 nodes, each connected to next 10 nodes
    N = 100
    graph = {i: {j: None for j in range(i+1, min(i+11, N+1))} for i in range(1, N+1)}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 418μs -> 87.6μs (377% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from __future__ import annotations

# imports
import pytest
from src.dsa.various import graph_traversal

# unit tests

# ---------------------------
# Basic Test Cases
# ---------------------------

def test_single_node_graph():
    # Graph with one node and no edges
    graph = {1: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.12μs -> 1.25μs (10.0% slower)

def test_two_nodes_one_direction():
    # Graph: 1 -> 2
    graph = {1: {2: None}, 2: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.38μs -> 1.62μs (15.4% slower)

def test_two_nodes_no_connection():
    # Graph: 1   2 (disconnected)
    graph = {1: {}, 2: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.08μs -> 1.21μs (10.3% slower)

def test_simple_cycle():
    # Graph: 1 -> 2 -> 1
    graph = {1: {2: None}, 2: {1: None}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.38μs -> 1.62μs (15.4% slower)

def test_three_node_chain():
    # Graph: 1 -> 2 -> 3
    graph = {1: {2: None}, 2: {3: None}, 3: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.54μs -> 1.67μs (7.50% slower)

def test_three_node_branch():
    # Graph: 1 -> 2, 1 -> 3
    graph = {1: {2: None, 3: None}, 2: {}, 3: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.58μs -> 1.71μs (7.37% slower)

def test_start_at_leaf():
    # Graph: 1 -> 2 -> 3, start at 3
    graph = {1: {2: None}, 2: {3: None}, 3: {}}
    codeflash_output = graph_traversal(graph, 3); result = codeflash_output # 1.08μs -> 1.25μs (13.4% slower)

# ---------------------------
# Edge Test Cases
# ---------------------------

def test_empty_graph():
    # Empty graph
    graph = {}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.12μs -> 1.29μs (12.9% slower)

def test_start_node_not_in_graph():
    # Start node not present in keys
    graph = {2: {3: None}, 3: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.08μs -> 1.25μs (13.4% slower)

def test_graph_with_self_loop():
    # Node with self-loop: 1 -> 1
    graph = {1: {1: None}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.21μs -> 1.42μs (14.7% slower)

def test_disconnected_graph():
    # Graph: 1 -> 2, 3 (disconnected)
    graph = {1: {2: None}, 2: {}, 3: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.33μs -> 1.50μs (11.1% slower)

def test_multiple_components():
    # Graph: 1 -> 2, 3 -> 4
    graph = {1: {2: None}, 2: {}, 3: {4: None}, 4: {}}
    codeflash_output = graph_traversal(graph, 1); result1 = codeflash_output # 1.33μs -> 1.38μs (3.05% slower)
    codeflash_output = graph_traversal(graph, 3); result2 = codeflash_output # 709ns -> 875ns (19.0% slower)

def test_graph_with_multiple_edges_to_same_node():
    # Graph: 1 -> 2, 1 -> 2 (duplicate edges)
    graph = {1: {2: None, 2: None}, 2: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.42μs -> 1.54μs (8.11% slower)

def test_graph_with_non_integer_keys():
    # Graph with string keys (should still work if keys are not int)
    graph = {'a': {'b': None}, 'b': {}}
    codeflash_output = graph_traversal(graph, 'a'); result = codeflash_output # 1.58μs -> 1.71μs (7.31% slower)

def test_graph_with_empty_dict_neighbors():
    # Graph with explicit empty dict as neighbors
    graph = {1: {}, 2: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.08μs -> 1.17μs (7.12% slower)

# ---------------------------
# Large Scale Test Cases
# ---------------------------


def test_large_star_topology():
    # Graph: 0 -> 1, 0 -> 2, ..., 0 -> 999
    N = 1000
    graph = {0: {i: None for i in range(1, N)}}
    for i in range(1, N):
        graph[i] = {}
    codeflash_output = graph_traversal(graph, 0); result = codeflash_output # 3.50ms -> 145μs (2313% faster)
    expected = [0] + list(range(1, N))

def test_large_complete_graph():
    # Complete graph: every node points to every other node
    N = 50  # keep small to avoid stack overflow in recursion
    graph = {i: {j: None for j in range(N) if j != i} for i in range(N)}
    codeflash_output = graph_traversal(graph, 0); result = codeflash_output # 523μs -> 107μs (385% faster)
    expected = list(range(N))

def test_large_disconnected_graph():
    # 500 nodes in two disconnected components
    N = 500
    graph = {i: {i+1: None} for i in range(N//2-1)}
    graph[N//2-1] = {}
    for i in range(N//2, N-1):
        graph[i] = {i+1: None}
    graph[N-1] = {}
    codeflash_output = graph_traversal(graph, 0); result1 = codeflash_output # 253μs -> 52.9μs (379% faster)
    codeflash_output = graph_traversal(graph, N//2); result2 = codeflash_output # 259μs -> 46.0μs (465% faster)


def test_mutation_guard_no_extra_nodes():
    # Should not visit nodes not in the graph or not reachable
    graph = {1: {2: None}, 2: {3: None}, 3: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 2.17μs -> 2.08μs (3.98% faster)

def test_mutation_guard_order():
    # Order should be DFS pre-order
    graph = {1: {2: None, 3: None}, 2: {4: None}, 3: {}, 4: {}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.83μs -> 2.00μs (8.35% slower)

def test_mutation_guard_repeat_visit():
    # Should not visit the same node twice
    graph = {1: {2: None, 3: None}, 2: {3: None}, 3: {1: None}}
    codeflash_output = graph_traversal(graph, 1); result = codeflash_output # 1.83μs -> 2.04μs (10.2% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from src.dsa.various import graph_traversal

def test_graph_traversal():
    graph_traversal({}, 2)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_fb1xiyqb/tmp0rb6oxxp/test_concolic_coverage.py::test_graph_traversal	1.08μs	1.25μs	-13.3%⚠️

To edit these changes git checkout codeflash/optimize-graph_traversal-mha62sr2 and push.