⚡️ Speed up function find_last_node by 13,461%

[codeflash-ai]

📄 13,461% (134.61x) speedup for find_last_node in src/algorithms/graph.py

⏱️ Runtime : 43.3 milliseconds → 320 microseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves a 135x speedup (from 43.3ms to 320μs) by fundamentally changing the algorithmic complexity from O(N×M) to O(N+M), where N is the number of nodes and M is the number of edges.

Key Optimization:

The original code uses nested iteration: for each node, it scans through all edges to check if that node appears as a source. This results in O(N×M) comparisons - catastrophic for larger graphs.

The optimized version pre-builds a set of all source IDs in O(M) time, then checks each node's membership in O(1) time, yielding O(N+M) total complexity. The set lookup (n["id"] not in sources) is orders of magnitude faster than repeatedly iterating through the edges list.

Why This Works:

1. Set-based membership testing: Python's hash-based sets provide O(1) average-case lookup versus O(M) linear search through edges
2. Single-pass edge traversal: Instead of scanning edges N times (once per node), we scan them once to build the set
3. Early termination preserved: The function still returns immediately upon finding the first terminal node

Performance Characteristics:

• Small graphs (few nodes/edges): 47-95% faster due to reduced overhead
• Linear chains (N nodes, N-1 edges): 2,840-37,284% faster - the difference grows dramatically with scale
• Dense graphs: 2,054-5,541% faster when many edges exist
• Sparse graphs (many terminal nodes): Returns quickly as the first terminal is found early

The optimization includes a fallback branch for single-pass iterators (preserving original semantics), though the fast path handles typical use cases with re-iterable collections like lists, which is why the test results show such dramatic improvements.

This optimization is especially valuable when find_last_node is called repeatedly or on graphs with hundreds of nodes/edges, transforming an O(N×M) bottleneck into a nearly linear-time operation.

✅ 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_last_node


def test_single_node_no_edges_returns_that_node():
    # One node and no edges: that node has no outgoing edges so it should be returned.
    nodes = [{"id": "only"}]  # construct the real node dict
    edges = []  # no edges
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.04μs -> 708ns (47.0% faster)


def test_first_node_returned_when_no_edges_multiple_nodes():
    # Multiple nodes but no edges: the first node has no outgoing edges and should be returned.
    nodes = [{"id": "A"}, {"id": "B"}, {"id": "C"}]
    edges = []  # no edges means all nodes are terminal; expect the first node
    codeflash_output = find_last_node(nodes, edges)  # 958ns -> 625ns (53.3% faster)


def test_terminal_node_when_one_node_has_outgoing_edge():
    # Node "A" has an outgoing edge to "B", so "B" is terminal and should be returned.
    nodes = [{"id": "A"}, {"id": "B"}]
    edges = [{"source": "A", "target": "B"}]
    codeflash_output = find_last_node(nodes, edges)  # 1.62μs -> 834ns (94.8% faster)


def test_multiple_terminals_returns_first_occurrence():
    # If several nodes are terminal, the function must return the first one in the nodes list.
    nodes = [{"id": "A"}, {"id": "B"}, {"id": "C"}]
    # Only "A" has outgoing edges; "B" and "C" are terminals -> should return "B"
    edges = [{"source": "A", "target": "B"}]
    codeflash_output = find_last_node(nodes, edges)  # 1.54μs -> 833ns (85.1% faster)


def test_int_ids_are_compared_strictly_by_type():
    # IDs that are ints should match edges whose "source" is the same int,
    # mismatching types (e.g. "1" vs 1) should not be considered equal.
    nodes = [{"id": 1}, {"id": "1"}]
    edges = [
        {"source": 1, "target": "dummy"}
    ]  # only the int-1 node has an outgoing edge
    # The string "1" node is terminal and should be returned
    codeflash_output = find_last_node(nodes, edges)  # 1.67μs -> 916ns (81.9% faster)


def test_missing_source_key_in_edge_raises_keyerror():
    # If an edge dict lacks 'source', the generator expression will attempt e["source"] and raise KeyError.
    nodes = [{"id": "A"}, {"id": "B"}]
    edges = [{"src": "A"}]  # wrong key name
    with pytest.raises(KeyError):
        find_last_node(nodes, edges)  # 1.92μs -> 1.00μs (91.6% faster)


def test_none_edge_in_edges_raises_typeerror():
    # If an edge item is None, attempting e["source"] will raise a TypeError.
    nodes = [{"id": "A"}]
    edges = [None]
    with pytest.raises(TypeError):
        find_last_node(nodes, edges)  # 2.08μs -> 1.38μs (51.6% faster)


def test_large_scale_all_but_last_have_outgoing_edges():
    # Build 1,000 nodes and edges from each node except the last to the next node.
    n = 1000  # size boundary requested
    nodes = [{"id": str(i)} for i in range(n)]  # node ids are strings "0".."999"
    # edges from node i to i+1 for i in 0..n-2: so the last node has no outgoing edges
    edges = [{"source": str(i), "target": str(i + 1)} for i in range(n - 1)]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 19.5ms -> 112μs (17317% faster)


def test_large_scale_no_edges_returns_first_node_consistently():
    # With many nodes but zero edges, the first node should always be returned quickly and deterministically.
    n = 1000
    nodes = [{"id": f"node_{i}"} for i in range(n)]
    edges = []
    codeflash_output = find_last_node(nodes, edges)  # 1.17μs -> 792ns (47.3% faster)


def test_large_scale_multiple_terminals_returns_earliest_terminal():
    # Create many nodes and sparse edges that make a later node terminal as well as an earlier one.
    n = 1000
    nodes = [{"id": f"id{i}"} for i in range(n)]
    edges = []
    # Create edges from every even-index node so that odd-index nodes are mostly terminal.
    for i in range(0, n, 2):
        # point even nodes to the next node when possible
        if i + 1 < n:
            edges.append({"source": nodes[i]["id"], "target": nodes[i + 1]["id"]})
    # The earliest terminal will be the first node that is not a source, which is nodes[1] (index 1)
    codeflash_output = find_last_node(nodes, edges)  # 20.2μs -> 32.0μs (37.1% slower)


# 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_last_node


def test_single_node_no_edges():
    """A single node with no edges should be returned as the terminal node."""
    nodes = [{"id": 1, "label": "A"}]
    edges = []
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.08μs -> 709ns (52.9% faster)


def test_linear_chain_three_nodes():
    """In a linear chain A→B→C, node C (no outgoing edge) should be returned."""
    nodes = [
        {"id": 1, "label": "A"},
        {"id": 2, "label": "B"},
        {"id": 3, "label": "C"},
    ]
    edges = [
        {"source": 1, "target": 2},
        {"source": 2, "target": 3},
    ]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 2.00μs -> 1.08μs (84.7% faster)


def test_two_nodes_one_edge():
    """Two nodes with one edge from A to B; B should be the terminal node."""
    nodes = [
        {"id": "a", "label": "Start"},
        {"id": "b", "label": "End"},
    ]
    edges = [{"source": "a", "target": "b"}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.58μs -> 875ns (80.9% faster)


def test_tree_structure_find_leaf():
    """In a tree structure with one root and multiple branches, find a leaf node."""
    nodes = [
        {"id": 1, "name": "root"},
        {"id": 2, "name": "left"},
        {"id": 3, "name": "right"},
        {"id": 4, "name": "leaf1"},
    ]
    edges = [
        {"source": 1, "target": 2},
        {"source": 1, "target": 3},
        {"source": 2, "target": 4},
    ]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 2.08μs -> 1.04μs (99.9% faster)


def test_multiple_terminal_nodes_returns_first():
    """When multiple nodes have no outgoing edges, return the first one in order."""
    nodes = [
        {"id": 1, "label": "A"},
        {"id": 2, "label": "B"},
        {"id": 3, "label": "C"},
    ]
    edges = [{"source": 1, "target": 2}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.50μs -> 875ns (71.4% faster)


def test_all_nodes_have_outgoing_edges_returns_none():
    """If every node has at least one outgoing edge, return None."""
    nodes = [
        {"id": 1, "label": "A"},
        {"id": 2, "label": "B"},
    ]
    edges = [
        {"source": 1, "target": 2},
        {"source": 2, "target": 1},
    ]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.62μs -> 917ns (77.2% faster)


def test_cycle_returns_none():
    """A cycle where all nodes have outgoing edges should return None."""
    nodes = [
        {"id": "x", "label": "X"},
        {"id": "y", "label": "Y"},
        {"id": "z", "label": "Z"},
    ]
    edges = [
        {"source": "x", "target": "y"},
        {"source": "y", "target": "z"},
        {"source": "z", "target": "x"},
    ]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 2.00μs -> 1.17μs (71.4% faster)


def test_node_with_string_id():
    """Node IDs can be strings; the function should handle them correctly."""
    nodes = [
        {"id": "node_1", "data": "first"},
        {"id": "node_2", "data": "second"},
    ]
    edges = [{"source": "node_1", "target": "node_2"}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.54μs -> 916ns (68.3% faster)


def test_node_with_complex_structure():
    """Nodes can have arbitrary additional fields; only 'id' matters for logic."""
    nodes = [
        {"id": 1, "name": "Start", "x": 0, "y": 0, "color": "red"},
        {"id": 2, "name": "End", "x": 100, "y": 100, "color": "green"},
    ]
    edges = [{"source": 1, "target": 2}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.58μs -> 917ns (72.7% faster)


def test_empty_nodes_list():
    """An empty nodes list should return None (no node matches)."""
    nodes = []
    edges = []
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 750ns -> 625ns (20.0% faster)


def test_empty_edges_list_multiple_nodes():
    """If there are no edges, the first node should be returned (all have no outgoing edges)."""
    nodes = [
        {"id": 1, "label": "A"},
        {"id": 2, "label": "B"},
        {"id": 3, "label": "C"},
    ]
    edges = []
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.04μs -> 666ns (56.5% faster)


def test_node_id_zero():
    """Node ID can be 0; ensure it's not treated as falsy incorrectly."""
    nodes = [
        {"id": 0, "label": "Zero"},
        {"id": 1, "label": "One"},
    ]
    edges = [{"source": 0, "target": 1}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.50μs -> 958ns (56.6% faster)


def test_node_id_negative():
    """Node ID can be negative; the function should handle it."""
    nodes = [
        {"id": -1, "label": "Negative"},
        {"id": 1, "label": "Positive"},
    ]
    edges = [{"source": -1, "target": 1}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.50μs -> 917ns (63.6% faster)


def test_node_id_none_as_value():
    """A node can have id=None (unusual but valid dict entry)."""
    nodes = [
        {"id": None, "label": "Null"},
        {"id": 1, "label": "One"},
    ]
    edges = [{"source": 1, "target": None}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.33μs -> 791ns (68.5% faster)


def test_edge_with_extra_fields():
    """Edges can have extra fields beyond 'source' and 'target'; only 'source' matters."""
    nodes = [
        {"id": 1, "label": "A"},
        {"id": 2, "label": "B"},
    ]
    edges = [{"source": 1, "target": 2, "weight": 5, "label": "connects to"}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.54μs -> 833ns (85.0% faster)


def test_self_loop_on_node():
    """A node with a self-loop (edge to itself) is still considered to have an outgoing edge."""
    nodes = [
        {"id": 1, "label": "A"},
        {"id": 2, "label": "B"},
    ]
    edges = [
        {"source": 1, "target": 1},  # self-loop
        {"source": 1, "target": 2},
    ]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.62μs -> 958ns (69.6% faster)


def test_multiple_edges_from_same_source():
    """A node can have multiple outgoing edges; function should still detect it correctly."""
    nodes = [
        {"id": 1, "label": "A"},
        {"id": 2, "label": "B"},
        {"id": 3, "label": "C"},
    ]
    edges = [
        {"source": 1, "target": 2},
        {"source": 1, "target": 3},
    ]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.58μs -> 875ns (80.9% faster)


def test_node_with_empty_dict():
    """A minimal node with only 'id' field should work."""
    nodes = [{"id": 1}]
    edges = []
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.04μs -> 667ns (56.2% faster)


def test_nodes_not_in_edges():
    """Some nodes may not appear in any edge at all."""
    nodes = [
        {"id": 1, "label": "Connected"},
        {"id": 2, "label": "Isolated"},
    ]
    edges = [{"source": 1, "target": 1}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.50μs -> 875ns (71.4% faster)


def test_large_id_values():
    """Node IDs can be very large integers."""
    nodes = [
        {"id": 10**18, "label": "Large"},
        {"id": 10**18 + 1, "label": "Larger"},
    ]
    edges = [{"source": 10**18, "target": 10**18 + 1}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.62μs -> 1.00μs (62.5% faster)


def test_uuid_like_string_ids():
    """Node IDs can be UUID-like strings."""
    nodes = [
        {"id": "550e8400-e29b-41d4-a716-446655440000", "label": "First"},
        {"id": "6ba7b810-9dad-11d1-80b4-00c04fd430c8", "label": "Second"},
    ]
    edges = [
        {
            "source": "550e8400-e29b-41d4-a716-446655440000",
            "target": "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
        }
    ]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.58μs -> 917ns (72.7% faster)


def test_numeric_string_ids():
    """Node IDs as numeric strings (not integers) should work."""
    nodes = [
        {"id": "1", "label": "A"},
        {"id": "2", "label": "B"},
    ]
    edges = [{"source": "1", "target": "2"}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.58μs -> 916ns (72.8% faster)


def test_case_sensitive_id_matching():
    """ID matching should be case-sensitive."""
    nodes = [
        {"id": "A", "label": "lowercase"},
        {"id": "a", "label": "uppercase"},
    ]
    edges = [{"source": "A", "target": "a"}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.54μs -> 834ns (84.8% faster)


def test_whitespace_in_ids():
    """Node IDs with whitespace should be treated literally."""
    nodes = [
        {"id": "node 1", "label": "First"},
        {"id": "node 2", "label": "Second"},
    ]
    edges = [{"source": "node 1", "target": "node 2"}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.54μs -> 875ns (76.2% faster)


def test_special_characters_in_ids():
    """Node IDs can contain special characters."""
    nodes = [
        {"id": "node@1", "label": "A"},
        {"id": "node#2", "label": "B"},
    ]
    edges = [{"source": "node@1", "target": "node#2"}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.50μs -> 833ns (80.1% faster)


def test_large_linear_chain_100_nodes():
    """A linear chain of 100 nodes; the last node should be found correctly."""
    nodes = [{"id": i, "label": f"Node_{i}"} for i in range(100)]
    edges = [{"source": i, "target": i + 1} for i in range(99)]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 205μs -> 7.00μs (2840% faster)


def test_large_linear_chain_1000_nodes():
    """A linear chain of 1000 nodes; performance and correctness verification."""
    nodes = [{"id": i, "label": f"Node_{i}"} for i in range(1000)]
    edges = [{"source": i, "target": i + 1} for i in range(999)]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 17.8ms -> 47.7μs (37284% faster)


def test_large_tree_256_nodes():
    """A binary tree with 256 nodes (8 levels); find a terminal leaf."""
    nodes = []
    edges = []
    node_id = 0
    # Build a complete binary tree level by level
    for i in range(128):  # parent nodes
        left_child = 2 * i + 1
        right_child = 2 * i + 2
        if left_child < 256:
            edges.append({"source": i, "target": left_child})
        if right_child < 256:
            edges.append({"source": i, "target": right_child})
    nodes = [{"id": i, "label": f"Node_{i}"} for i in range(256)]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 604μs -> 10.7μs (5541% faster)


def test_star_topology_500_nodes():
    """Star topology: one central node connects to 499 others (all others are terminal)."""
    nodes = [{"id": i, "label": f"Node_{i}"} for i in range(500)]
    edges = [{"source": 0, "target": i} for i in range(1, 500)]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 20.6μs -> 10.0μs (105% faster)


def test_dense_graph_many_edges():
    """A graph with 50 nodes and many interconnecting edges; find terminal if exists."""
    nodes = [{"id": i, "label": f"Node_{i}"} for i in range(50)]
    edges = []
    # Create edges where node i connects to node (i+1) and (i+2)
    for i in range(50):
        if i + 1 < 50:
            edges.append({"source": i, "target": i + 1})
        if i + 2 < 50:
            edges.append({"source": i, "target": i + 2})
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 102μs -> 4.75μs (2054% faster)


def test_fully_connected_graph_30_nodes():
    """A complete graph where every node connects to every other node; no terminal."""
    nodes = [{"id": i, "label": f"Node_{i}"} for i in range(30)]
    edges = []
    for i in range(30):
        for j in range(30):
            if i != j:
                edges.append({"source": i, "target": j})
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 458μs -> 19.2μs (2290% faster)


def test_multi_level_hierarchy_100_nodes():
    """A multi-level hierarchy with several leaf nodes at the bottom."""
    nodes = [{"id": i, "label": f"Node_{i}"} for i in range(100)]
    edges = []
    # Create a hierarchy: nodes 0-9 connect to 10-99 (10 levels × 10 nodes per level)
    for i in range(10):
        for j in range(10, 100):
            if j < (i + 1) * 10:
                edges.append({"source": i, "target": j})
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 18.5μs -> 9.75μs (90.2% faster)


def test_disconnected_components_200_nodes():
    """Multiple disconnected components; find terminal in one of them."""
    nodes = [{"id": i, "label": f"Node_{i}"} for i in range(200)]
    edges = []
    # Create 10 disconnected chains of 20 nodes each
    for chain in range(10):
        start = chain * 20
        for i in range(start, start + 19):
            edges.append({"source": i, "target": i + 1})
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 18.9μs -> 6.17μs (206% faster)


def test_long_chain_with_branch_at_end():
    """A long linear chain (500 nodes) with a branch at the very end."""
    nodes = [{"id": i, "label": f"Node_{i}"} for i in range(502)]
    edges = [{"source": i, "target": i + 1} for i in range(500)]
    # Add a branch from node 499 to nodes 500 and 501
    edges.append({"source": 499, "target": 500})
    edges.append({"source": 499, "target": 501})
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 4.48ms -> 26.3μs (16934% faster)


def test_performance_many_edges_per_node():
    """Test performance with nodes that have many outgoing edges."""
    nodes = [{"id": i, "label": f"Node_{i}"} for i in range(100)]
    edges = []
    # Node 0 connects to all other nodes
    for i in range(1, 100):
        edges.append({"source": 0, "target": i})
    # Node 1 connects to nodes 2-99
    for i in range(2, 100):
        edges.append({"source": 1, "target": i})
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 13.0μs -> 4.79μs (170% 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_last_node-mlrz2na9 and push.