⚡️ Speed up function find_leaf_nodes by 16,375%

[codeflash-ai]

📄 16,375% (163.75x) speedup for find_leaf_nodes in src/algorithms/graph.py

⏱️ Runtime : 39.1 milliseconds → 237 microseconds (best of 182 runs)

📝 Explanation and details

The optimized code achieves a 164x speedup (from 39.1ms to 237μs) by eliminating an expensive nested loop pattern that scaled poorly with graph size.

Key Optimizations

1. Algorithmic Improvement: O(N×M) → O(N+M)
The original code used a nested loop where for each node, it iterated through all edges to check for outgoing connections. This resulted in O(N×M) complexity where N is the number of nodes and M is the number of edges.

The optimized version builds a set of all source node IDs once (sources = {edge["source"] for edge in edges}), then performs O(1) membership checks for each node. This reduces complexity to O(N+M), providing dramatic speedups especially as graph size increases.

2. Fast Path for Empty Edges
When there are no edges, all nodes are leaves. The optimization immediately returns a shallow copy of the nodes list, avoiding unnecessary iteration.

Why This Works

From the line profiler data, the original code spent:

• 45.4% of time iterating through edges (367.6ms)
• 53.7% of time checking edge["source"] == node["id"] (434.7ms)

These nested dictionary lookups happened 1.28 million times across all function calls. The optimized version performs dictionary lookups only during set construction, then uses fast hash-based membership checks.

Performance Characteristics

The test results show the optimization scales exceptionally well:

• Small graphs (3-10 nodes): 16-62% faster
• Medium graphs (100 nodes): 2,600-5,900% faster
• Large graphs (1000 nodes): 24,700-32,000% faster

The speedup increases with graph density. For example:

• Linear chain (1000 nodes, 999 edges): 320x faster (15.1ms → 46.9μs)
• Dense graph (200 nodes, 600 edges): 96x faster (1.89ms → 19.5μs)
• 500 nodes with single source: 234x faster (7.66ms → 32.7μs)

This optimization is particularly valuable for any workload processing moderately-sized graphs, transforming what was a millisecond-scale operation into microsecond-scale, enabling much higher throughput for graph analysis pipelines.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import pytest  # used for our unit tests
from src.algorithms.graph import find_leaf_nodes

def test_empty_inputs_return_empty_list():
    # Empty nodes list and empty edges list should produce an empty result.
    nodes = []  # no nodes in the graph
    edges = []  # no edges in the graph
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 333ns -> 333ns (0.000% faster)

def test_no_edges_all_nodes_are_leaves_order_preserved():
    # When there are nodes but no edges, every node is a leaf; order should be preserved.
    nodes = [
        {"id": "A", "label": "alpha"},
        {"id": "B", "label": "beta"},
        {"id": "C", "label": "gamma"},
    ]
    edges = []  # no edges => all nodes are leaves
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 708ns -> 333ns (113% faster)

def test_simple_tree_identifies_leaves_correctly():
    # Simple tree: node 1 points to 2 and 3, so 2 and 3 are leaves while 1 is not.
    nodes = [{"id": 1}, {"id": 2}, {"id": 3}]
    edges = [{"source": 1, "target": 2}, {"source": 1, "target": 3}]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.17μs -> 1.00μs (16.6% faster)

def test_self_loop_node_is_not_a_leaf():
    # A self-loop means the node has an outgoing edge to itself and therefore is not a leaf.
    nodes = [{"id": "loop"}, {"id": "other"}]
    edges = [{"source": "loop", "target": "loop"}]  # self-loop on 'loop'
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.08μs -> 792ns (36.7% faster)

def test_duplicate_node_entries_with_same_id():
    # If nodes list contains duplicate dicts with the same id, behavior should be consistent:
    # if an outgoing edge exists for that id, none of the duplicates should be considered a leaf.
    node_a1 = {"id": 42, "label": "first"}
    node_a2 = {"id": 42, "label": "second"}
    nodes = [node_a1, node_a2, {"id": 99}]
    edges = [{"source": 42, "target": 99}]  # outgoing edge from id 42
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.08μs -> 834ns (29.9% faster)

def test_edge_sources_that_do_not_match_any_node_are_ignored():
    # Edges that refer to source ids not present in nodes should not affect existing nodes.
    nodes = [{"id": "present"}]
    edges = [{"source": "absent", "target": "present"}]  # source not in nodes
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 750ns -> 709ns (5.78% faster)

def test_nodes_with_various_id_types_strings_and_none():
    # Node ids can be strings, integers, None, or other hashable types; the function should use equality.
    nodes = [{"id": None}, {"id": "☃"}, {"id": 0}]
    edges = [{"source": "☃", "target": None}]  # outgoing from the snowman string id
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.29μs -> 917ns (40.9% faster)

def test_input_nodes_not_modified_by_function():
    # The function should not mutate the nodes list or the node dicts.
    nodes = [{"id": 1, "meta": {"visited": False}}, {"id": 2}]
    edges = [{"source": 1, "target": 2}]
    # Make a deep-ish copy to compare after call (only top-level deterministic inspection required).
    import copy
    before_nodes = copy.deepcopy(nodes)
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 875ns -> 791ns (10.6% faster)

def test_order_of_nodes_preserved_after_filtering():
    # Leaves should be returned in the same order as they appeared in 'nodes'.
    nodes = [{"id": "first"}, {"id": "middle"}, {"id": "last"}]
    edges = [{"source": "middle", "target": "last"}]  # middle is not a leaf
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.21μs -> 875ns (38.1% faster)

def test_large_scale_chain_graph_last_node_only_leaf():
    # Create a chain of 1000 nodes where each node i points to i+1.
    # Only the final node should be a leaf.
    n = 1000  # size just at the upper bound requested
    nodes = [{"id": i} for i in range(n)]
    edges = [{"source": i, "target": i + 1} for i in range(n - 1)]  # chain links
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 15.1ms -> 46.9μs (32027% faster)

def test_large_scale_all_nodes_are_leaves_when_no_edges():
    # With 1000 nodes and no edges, every node should be returned as a leaf.
    n = 1000
    nodes = [{"id": f"node-{i}"} for i in range(n)]
    edges = []  # no edges
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 32.6μs -> 1.88μs (1640% faster)

def test_large_scale_many_edges_non_overlapping_sources():
    # Create 1000 nodes and 500 edges whose sources are half of the nodes.
    # Expect the 500 nodes that are not sources to be leaves.
    nodes = [{"id": i} for i in range(1000)]
    # Make edges for even node ids only
    edges = [{"source": i, "target": i + 1000} for i in range(0, 1000, 2)]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 11.4ms -> 45.8μs (24704% faster)
    # Leaves should be odd ids only (those without outgoing edges), in original order.
    expected = [{"id": i} for i in range(1000) if i % 2 == 1]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest
from src.algorithms.graph import find_leaf_nodes

def test_single_leaf_node():
    """Test with a single node that has no outgoing edges."""
    nodes = [{"id": 1, "name": "node1"}]
    edges = []
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 542ns -> 334ns (62.3% faster)

def test_all_nodes_are_leaves():
    """Test when all nodes have no outgoing edges."""
    nodes = [
        {"id": 1, "name": "node1"},
        {"id": 2, "name": "node2"},
        {"id": 3, "name": "node3"},
    ]
    edges = []
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 625ns -> 292ns (114% faster)

def test_single_node_with_outgoing_edge():
    """Test with a single node that has an outgoing edge (not a leaf)."""
    nodes = [{"id": 1, "name": "node1"}]
    edges = [{"source": 1, "target": 2}]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 666ns -> 666ns (0.000% faster)

def test_simple_linear_graph():
    """Test with a simple linear chain: node1 -> node2 -> node3."""
    nodes = [
        {"id": 1, "name": "node1"},
        {"id": 2, "name": "node2"},
        {"id": 3, "name": "node3"},
    ]
    edges = [
        {"source": 1, "target": 2},
        {"source": 2, "target": 3},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.08μs -> 917ns (18.1% faster)

def test_multiple_leaf_nodes():
    """Test with multiple leaf nodes in a tree structure."""
    nodes = [
        {"id": 1, "name": "root"},
        {"id": 2, "name": "child1"},
        {"id": 3, "name": "child2"},
        {"id": 4, "name": "grandchild"},
    ]
    edges = [
        {"source": 1, "target": 2},
        {"source": 1, "target": 3},
        {"source": 2, "target": 4},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.46μs -> 1.04μs (39.9% faster)
    result_ids = [node["id"] for node in result]

def test_mixed_leaf_and_non_leaf():
    """Test with a mix of leaf and non-leaf nodes."""
    nodes = [
        {"id": "a", "value": 1},
        {"id": "b", "value": 2},
        {"id": "c", "value": 3},
    ]
    edges = [
        {"source": "a", "target": "b"},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.17μs -> 916ns (27.4% faster)
    result_ids = [node["id"] for node in result]

def test_node_with_multiple_outgoing_edges():
    """Test with a node that has multiple outgoing edges."""
    nodes = [
        {"id": 1},
        {"id": 2},
        {"id": 3},
        {"id": 4},
    ]
    edges = [
        {"source": 1, "target": 2},
        {"source": 1, "target": 3},
        {"source": 1, "target": 4},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.42μs -> 958ns (47.9% faster)
    result_ids = [node["id"] for node in result]

def test_empty_nodes_list():
    """Test with an empty nodes list."""
    nodes = []
    edges = [{"source": 1, "target": 2}]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 375ns -> 500ns (25.0% slower)

def test_empty_edges_list():
    """Test with an empty edges list (all nodes are leaves)."""
    nodes = [
        {"id": 1},
        {"id": 2},
        {"id": 3},
    ]
    edges = []
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 667ns -> 333ns (100% faster)

def test_both_empty():
    """Test with both empty nodes and edges lists."""
    nodes = []
    edges = []
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 334ns -> 375ns (10.9% slower)

def test_node_with_self_loop():
    """Test with a node that has an edge pointing to itself."""
    nodes = [
        {"id": 1, "name": "self_loop"},
        {"id": 2, "name": "leaf"},
    ]
    edges = [
        {"source": 1, "target": 1},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 916ns -> 791ns (15.8% faster)

def test_string_ids():
    """Test with string IDs instead of integers."""
    nodes = [
        {"id": "nodeA"},
        {"id": "nodeB"},
        {"id": "nodeC"},
    ]
    edges = [
        {"source": "nodeA", "target": "nodeB"},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.29μs -> 833ns (55.0% faster)
    result_ids = [node["id"] for node in result]

def test_node_with_extra_fields():
    """Test with nodes containing extra fields beyond id."""
    nodes = [
        {"id": 1, "name": "first", "color": "red", "weight": 10},
        {"id": 2, "name": "second", "color": "blue", "weight": 20},
    ]
    edges = [
        {"source": 1, "target": 2},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 917ns -> 791ns (15.9% faster)

def test_edge_with_extra_fields():
    """Test with edges containing extra fields beyond source and target."""
    nodes = [
        {"id": 1},
        {"id": 2},
        {"id": 3},
    ]
    edges = [
        {"source": 1, "target": 2, "weight": 5, "label": "edge1"},
        {"source": 2, "target": 3, "weight": 10, "label": "edge2"},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.17μs -> 875ns (33.3% faster)

def test_disconnected_graph_components():
    """Test with multiple disconnected graph components."""
    nodes = [
        {"id": 1},
        {"id": 2},
        {"id": 3},
        {"id": 4},
        {"id": 5},
    ]
    # Component 1: 1 -> 2
    # Component 2: 3 -> 4
    # Isolated: 5
    edges = [
        {"source": 1, "target": 2},
        {"source": 3, "target": 4},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.50μs -> 1.04μs (44.1% faster)
    result_ids = [node["id"] for node in result]

def test_cyclic_graph():
    """Test with a cyclic graph structure."""
    nodes = [
        {"id": 1},
        {"id": 2},
        {"id": 3},
    ]
    # Cycle: 1 -> 2 -> 3 -> 1
    edges = [
        {"source": 1, "target": 2},
        {"source": 2, "target": 3},
        {"source": 3, "target": 1},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.12μs -> 875ns (28.6% faster)

def test_numeric_zero_as_id():
    """Test with zero as a node ID."""
    nodes = [
        {"id": 0},
        {"id": 1},
    ]
    edges = [
        {"source": 0, "target": 1},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 916ns -> 833ns (9.96% faster)

def test_negative_ids():
    """Test with negative integer IDs."""
    nodes = [
        {"id": -1},
        {"id": -2},
        {"id": 0},
    ]
    edges = [
        {"source": -1, "target": -2},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.12μs -> 1.08μs (3.78% faster)
    result_ids = [node["id"] for node in result]

def test_uuid_like_ids():
    """Test with UUID-like string IDs."""
    nodes = [
        {"id": "550e8400-e29b-41d4-a716-446655440000"},
        {"id": "550e8400-e29b-41d4-a716-446655440001"},
    ]
    edges = [
        {"source": "550e8400-e29b-41d4-a716-446655440000", "target": "550e8400-e29b-41d4-a716-446655440001"},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.08μs -> 792ns (36.7% faster)

def test_nodes_not_in_edges():
    """Test when some nodes are not referenced in any edges."""
    nodes = [
        {"id": 1},
        {"id": 2},
        {"id": 3},
        {"id": 4},
    ]
    edges = [
        {"source": 1, "target": 2},
    ]
    # Nodes 2, 3, 4 are leaves (3 and 4 are never referenced)
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.12μs -> 917ns (22.7% faster)
    result_ids = [node["id"] for node in result]

def test_edges_reference_non_existent_nodes():
    """Test when edges reference node IDs not in the nodes list."""
    nodes = [
        {"id": 1},
        {"id": 2},
    ]
    edges = [
        {"source": 1, "target": 2},
        {"source": 2, "target": 999},  # 999 doesn't exist in nodes
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 917ns -> 750ns (22.3% faster)

def test_preserve_node_order_in_result():
    """Test that the result maintains the order of nodes from input."""
    nodes = [
        {"id": 3},
        {"id": 1},
        {"id": 2},
    ]
    edges = [
        {"source": 2, "target": 3},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.08μs -> 916ns (18.2% faster)

def test_duplicate_nodes_in_input():
    """Test behavior when duplicate nodes are in the input list."""
    nodes = [
        {"id": 1, "name": "first"},
        {"id": 2},
        {"id": 1, "name": "duplicate"},
    ]
    edges = [
        {"source": 1, "target": 2},
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.04μs -> 875ns (19.1% faster)

def test_duplicate_edges():
    """Test behavior when there are duplicate edges."""
    nodes = [
        {"id": 1},
        {"id": 2},
    ]
    edges = [
        {"source": 1, "target": 2},
        {"source": 1, "target": 2},  # Duplicate
    ]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.00μs -> 875ns (14.3% faster)

def test_large_linear_chain_100_nodes():
    """Test with a large linear chain of 100 nodes."""
    nodes = [{"id": i} for i in range(100)]
    edges = [{"source": i, "target": i + 1} for i in range(99)]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 173μs -> 6.38μs (2622% faster)

def test_large_star_graph_100_nodes():
    """Test with a star graph: 1 root with 99 children."""
    nodes = [{"id": i} for i in range(100)]
    edges = [{"source": 0, "target": i} for i in range(1, 100)]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 322μs -> 7.96μs (3955% faster)
    result_ids = set(node["id"] for node in result)
    for i in range(1, 100):
        pass

def test_large_complete_binary_tree_127_nodes():
    """Test with a complete binary tree of 127 nodes (7 levels)."""
    nodes = [{"id": i} for i in range(127)]
    edges = []
    # Binary tree: node i has children 2*i+1 and 2*i+2
    for i in range(63):  # Parents up to node 62
        edges.append({"source": i, "target": 2 * i + 1})
        edges.append({"source": i, "target": 2 * i + 2})
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 372μs -> 8.33μs (4375% faster)
    result_ids = set(node["id"] for node in result)
    for i in range(63, 127):
        pass

def test_many_isolated_nodes_500():
    """Test with 500 isolated nodes and no edges."""
    nodes = [{"id": i} for i in range(500)]
    edges = []
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 17.1μs -> 1.08μs (1477% faster)

def test_500_nodes_single_source():
    """Test with 500 nodes where one node points to all others."""
    nodes = [{"id": i} for i in range(500)]
    edges = [{"source": 0, "target": i} for i in range(1, 500)]
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 7.66ms -> 32.7μs (23327% faster)
    result_ids = set(node["id"] for node in result)
    for i in range(1, 500):
        pass

def test_large_graph_with_mixed_connectivity():
    """Test with 300 nodes and complex connectivity patterns."""
    nodes = [{"id": i, "value": i * 2} for i in range(300)]
    edges = []
    # Create edges in patterns: some chains, some branches
    for i in range(0, 100, 10):
        for j in range(10):
            if i + j < 299:
                edges.append({"source": i + j, "target": i + j + 1})
    # Add some cross-edges
    for i in range(100, 200):
        edges.append({"source": i, "target": i + 100})
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.29ms -> 15.2μs (8397% faster)
    result_ids = set(node["id"] for node in result)
    # Verify all result nodes exist in input
    for node in result:
        pass

def test_performance_with_many_edges():
    """Test performance with 100 nodes and 500 edges."""
    nodes = [{"id": i} for i in range(100)]
    edges = []
    # Create 500 edges randomly distributed
    for i in range(500):
        source = i % 100
        target = (i + 1) % 100
        edges.append({"source": source, "target": target})
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 170μs -> 15.0μs (1037% faster)

def test_dense_graph_200_nodes():
    """Test with a relatively dense graph of 200 nodes."""
    nodes = [{"id": i} for i in range(200)]
    edges = []
    # Each node points to the next 3 nodes (wrap around)
    for i in range(200):
        for j in range(1, 4):
            target = (i + j) % 200
            edges.append({"source": i, "target": target})
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 1.89ms -> 19.5μs (9584% faster)

def test_tree_with_many_children_per_node():
    """Test with a shallow tree where each node has many children."""
    nodes = [{"id": i} for i in range(155)]
    edges = []
    # Root node has 50 children, each child has 2 children
    for i in range(1, 51):
        edges.append({"source": 0, "target": i})
    for i in range(1, 51):
        edges.append({"source": i, "target": 50 + 2 * (i - 1) + 1})
        edges.append({"source": i, "target": 50 + 2 * (i - 1) + 2})
    codeflash_output = find_leaf_nodes(nodes, edges); result = codeflash_output # 665μs -> 11.1μs (5886% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-find_leaf_nodes-mlulvjd2 and push.