⚡️ Speed up function find_last_node by 9,164%

[codeflash-ai]

📄 9,164% (91.64x) speedup for find_last_node in src/algorithms/graph.py

⏱️ Runtime : 47.1 milliseconds → 509 microseconds (best of 210 runs)

📝 Explanation and details

The optimized code achieves a 92x runtime improvement (47.1ms → 509μs) by fundamentally changing the algorithm's time 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

Pre-compute source set instead of repeated lookups: The original code uses a nested loop structure - for each node, it checks ALL edges to see if that node appears as a source (all(e["source"] != n["id"] for e in edges)). This creates quadratic behavior that becomes expensive as the graph grows.

The optimized version:

1. Builds a set of all source IDs once (sources = set(e["source"] for e in edges)) - O(M) operation
2. Performs O(1) set membership checks for each node (n["id"] not in sources) instead of O(M) linear scans
3. Falls back gracefully to the original approach if edges contain unhashable types (like dicts/lists) or missing "source" keys

Why This Works

Sets in Python use hash tables, making membership checks effectively constant time. By extracting all source IDs upfront, we avoid redundantly scanning the edges list for every single node. The try-except ensures correctness when dealing with edge cases like missing keys or unhashable node IDs.

Performance Characteristics

The optimization shines brightest on larger graphs:

• 1000-node chain: 19.6ms → 125μs (156x faster)
• 500-node chain: 4.82ms → 32.8μs (146x faster)
• Complete graph (50 nodes, 1225 edges): 1.60ms → 45.0μs (35x faster)
• Binary tree (127 nodes): 187μs → 8.25μs (23x faster)

Small graphs see modest improvements (2-3μs → 1-2μs) since the overhead of set construction becomes proportionally larger, but the optimization never regresses on valid inputs. Edge cases like empty nodes or missing keys handle correctly via the fallback path with minimal overhead (2-3μs).

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 37 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():
    # A single node with no edges should be considered the last node.
    node = {"id": "A"}  # construct a real dict node
    nodes = [node]  # list containing the node
    edges = []  # no edges
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 1.38μs -> 1.38μs (0.000% faster)

def test_simple_chain_returns_terminal_node():
    # A simple chain A -> B -> C should return C as it never appears as a source.
    a = {"id": "A"}
    b = {"id": "B"}
    c = {"id": "C"}
    nodes = [a, b, c]  # order: A, B, C
    edges = [
        {"source": "A", "target": "B"},
        {"source": "B", "target": "C"},
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 2.75μs -> 1.75μs (57.1% faster)

def test_duplicates_and_empty_edges_return_first_node():
    # When edges are empty and nodes contain duplicate ids, the first node in the list should be returned.
    first = {"id": 1, "label": "first"}
    second = {"id": 1, "label": "second"}  # duplicate id
    nodes = [first, second]
    edges = []  # no edges; nothing excludes the first node
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 1.42μs -> 1.33μs (6.22% faster)

def test_no_nodes_returns_none():
    # If there are no nodes, the function cannot find a last node and must return None.
    nodes = []
    edges = [{"source": "x", "target": "y"}]  # arbitrary edges
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 792ns -> 1.42μs (44.1% slower)

def test_node_with_none_id_excluded_by_none_source_edge():
    # If a node's id is None and an edge has source None, that node must not be returned.
    n_none = {"id": None, "payload": "none-id"}
    n_ok = {"id": "ok"}
    nodes = [n_none, n_ok]
    edges = [{"source": None, "target": "ok"}]  # explicitly references None as source
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 2.29μs -> 1.54μs (48.7% faster)

def test_node_with_none_id_returned_if_no_none_source_present():
    # If a node's id is None but no edge has source None, it should be a valid last node candidate.
    n_none = {"id": None}
    nodes = [n_none]
    edges = [{"source": "something_else"}]  # no None source present
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 1.71μs -> 1.50μs (13.9% faster)

def test_edge_missing_source_key_raises_keyerror():
    # If any edge dict is missing the "source" key, the comprehension will attempt e["source"] and raise KeyError.
    nodes = [{"id": "A"}]
    edges = [{"target": "B"}]  # missing 'source'
    with pytest.raises(KeyError):
        find_last_node(nodes, edges) # 2.67μs -> 3.00μs (11.1% slower)

def test_mismatched_types_do_not_match_equality():
    # If an edge's source is an int and node id is the string of that int, they should not be considered equal.
    node = {"id": "1"}  # string id
    nodes = [node]
    edges = [{"source": 1}]  # integer source
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 1.92μs -> 1.62μs (17.9% faster)

def test_large_chain_of_1000_nodes_returns_last_quickly():
    # Build 1000 nodes n0..n999 and edges n0->n1, n1->n2, ..., n998->n999.
    size = 1000
    nodes = [{"id": f"n{i}"} for i in range(size)]  # construct 1000 node dicts
    # Create chain edges so every node except the last appears as a source
    edges = [{"source": f"n{i}", "target": f"n{i+1}"} for i in range(size - 1)]
    # The last node ("n999") is never a source, so it should be returned.
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 19.6ms -> 125μs (15590% faster)

def test_large_cycle_of_1000_nodes_returns_none():
    # Build 1000 nodes and create edges that make a full cycle so every node appears as a source.
    size = 1000
    nodes = [{"id": f"node{i}"} for i in range(size)]
    # For i in 0..999 create source node{i} -> node{(i+1) % size}, so every node is a source somewhere.
    edges = [{"source": f"node{i}", "target": f"node{(i + 1) % size}"} for i in range(size)]
    # Since every node appears as a source, there is no node that satisfies the "no source" condition.
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 20.0ms -> 132μs (14984% faster)
# 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():
    """Test with a single node and no edges - should return that node."""
    nodes = [{"id": "a", "label": "Node A"}]
    edges = []
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 1.54μs -> 1.38μs (12.1% faster)

def test_linear_chain_returns_last():
    """Test with a linear chain: A -> B -> C. Should return C (the last node)."""
    nodes = [
        {"id": "a", "label": "Node A"},
        {"id": "b", "label": "Node B"},
        {"id": "c", "label": "Node C"}
    ]
    edges = [
        {"source": "a", "target": "b"},
        {"source": "b", "target": "c"}
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 2.54μs -> 1.75μs (45.3% faster)

def test_two_nodes_one_edge():
    """Test with two nodes where first points to second."""
    nodes = [
        {"id": "start", "label": "Start"},
        {"id": "end", "label": "End"}
    ]
    edges = [{"source": "start", "target": "end"}]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 2.08μs -> 1.58μs (31.5% faster)

def test_multiple_branches_finds_leaf():
    """Test with branching paths: A -> B, A -> C. Both B and C are leaves."""
    nodes = [
        {"id": "a", "label": "Root"},
        {"id": "b", "label": "Left"},
        {"id": "c", "label": "Right"}
    ]
    edges = [
        {"source": "a", "target": "b"},
        {"source": "a", "target": "c"}
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 2.08μs -> 1.75μs (19.0% faster)

def test_node_with_extra_properties():
    """Test that nodes with additional properties are handled correctly."""
    nodes = [
        {"id": "1", "type": "start", "x": 100, "y": 50},
        {"id": "2", "type": "end", "x": 200, "y": 50}
    ]
    edges = [{"source": "1", "target": "2"}]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 1.96μs -> 1.54μs (27.1% faster)

def test_empty_nodes_list():
    """Test with empty nodes list - should return None."""
    nodes = []
    edges = []
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 833ns -> 1.21μs (31.0% slower)

def test_empty_edges_first_node_is_last():
    """Test with nodes but no edges - first node should be returned."""
    nodes = [{"id": "only", "label": "Only Node"}]
    edges = []
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 1.29μs -> 1.33μs (3.08% slower)

def test_empty_edges_multiple_nodes():
    """Test with multiple nodes but no edges - all qualify, first is returned."""
    nodes = [
        {"id": "1"},
        {"id": "2"},
        {"id": "3"}
    ]
    edges = []
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 1.29μs -> 1.25μs (3.36% faster)

def test_self_loop():
    """Test node with a self-loop edge - should not be considered a leaf."""
    nodes = [
        {"id": "a"},
        {"id": "b"}
    ]
    edges = [
        {"source": "a", "target": "a"}  # Self-loop
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 2.00μs -> 1.58μs (26.3% faster)

def test_cycle_in_graph():
    """Test with a cycle: A -> B -> C -> A. All have outgoing edges."""
    nodes = [
        {"id": "a"},
        {"id": "b"},
        {"id": "c"}
    ]
    edges = [
        {"source": "a", "target": "b"},
        {"source": "b", "target": "c"},
        {"source": "c", "target": "a"}
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 2.50μs -> 1.71μs (46.3% faster)

def test_complete_cycle_no_leaf():
    """Test where every node has an outgoing edge."""
    nodes = [
        {"id": "x"},
        {"id": "y"},
        {"id": "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.46μs -> 1.71μs (43.9% faster)

def test_node_id_as_integer():
    """Test with integer IDs instead of strings."""
    nodes = [
        {"id": 1, "name": "First"},
        {"id": 2, "name": "Second"}
    ]
    edges = [{"source": 1, "target": 2}]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 2.04μs -> 1.62μs (25.6% faster)

def test_edges_with_extra_fields():
    """Test that edge objects with extra fields don't affect behavior."""
    nodes = [
        {"id": "a"},
        {"id": "b"},
        {"id": "c"}
    ]
    edges = [
        {
            "source": "a",
            "target": "b",
            "weight": 10,
            "label": "edge1",
            "color": "red"
        },
        {
            "source": "b",
            "target": "c",
            "weight": 20,
            "label": "edge2"
        }
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 2.29μs -> 1.71μs (34.2% faster)

def test_source_field_none_in_edge():
    """Test edge where source field exists but might be None."""
    nodes = [
        {"id": "a"},
        {"id": "b"}
    ]
    edges = [
        {"source": "a", "target": "b"}
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 1.92μs -> 1.54μs (24.3% faster)

def test_diamond_graph_structure():
    """Test diamond shape: A -> B, A -> C, B -> D, C -> D."""
    nodes = [
        {"id": "a"},
        {"id": "b"},
        {"id": "c"},
        {"id": "d"}
    ]
    edges = [
        {"source": "a", "target": "b"},
        {"source": "a", "target": "c"},
        {"source": "b", "target": "d"},
        {"source": "c", "target": "d"}
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 2.88μs -> 1.88μs (53.3% faster)

def test_node_not_in_any_edge():
    """Test with a node that doesn't appear in any edge."""
    nodes = [
        {"id": "a"},
        {"id": "b"},
        {"id": "isolated"}
    ]
    edges = [
        {"source": "a", "target": "b"}
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 2.00μs -> 1.54μs (29.8% faster)

def test_multiple_nodes_with_no_outgoing_edges():
    """Test where multiple nodes have no outgoing edges - returns first."""
    nodes = [
        {"id": "a"},
        {"id": "b"},
        {"id": "c"},
        {"id": "d"}
    ]
    edges = [
        {"source": "a", "target": "b"}
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 1.92μs -> 1.54μs (24.3% faster)

def test_large_linear_chain_100_nodes():
    """Test with 100 nodes in a linear chain."""
    # Build a chain: 0 -> 1 -> 2 -> ... -> 99
    nodes = [{"id": 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 # 230μs -> 8.79μs (2525% faster)

def test_large_linear_chain_500_nodes():
    """Test with 500 nodes in a linear chain."""
    nodes = [{"id": i, "value": i * 2} for i in range(500)]
    edges = [{"source": i, "target": i + 1} for i in range(499)]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 4.82ms -> 32.8μs (14597% faster)

def test_large_complete_graph_50_nodes():
    """Test where most nodes have outgoing edges (complete graph structure)."""
    n = 50
    nodes = [{"id": i} for i in range(n)]
    # Create edges from each node to all nodes with higher IDs
    edges = [
        {"source": i, "target": j}
        for i in range(n - 1)
        for j in range(i + 1, n)
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 1.60ms -> 45.0μs (3458% faster)

def test_large_star_graph_100_nodes():
    """Test star topology: central node connects to 99 leaf nodes."""
    nodes = [
        {"id": "center"}
    ] + [{"id": f"leaf_{i}"} for i in range(99)]
    # Center node connects to all leaves
    edges = [
        {"source": "center", "target": f"leaf_{i}"}
        for i in range(99)
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 8.38μs -> 5.12μs (63.4% faster)

def test_large_many_independent_chains():
    """Test 20 independent chains of 50 nodes each."""
    nodes = [
        {"id": f"chain_{c}_node_{n}"}
        for c in range(20)
        for n in range(50)
    ]
    edges = [
        {"source": f"chain_{c}_node_{n}", "target": f"chain_{c}_node_{n+1}"}
        for c in range(20)
        for n in range(49)
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 109μs -> 84.6μs (29.2% faster)

def test_large_complex_graph_200_edges():
    """Test with 50 nodes and 200 edge definitions."""
    nodes = [{"id": i} for i in range(50)]
    # Create edges ensuring at least one node has no outgoing edges
    edges = []
    for i in range(50):
        for j in range(i + 1, min(i + 5, 50)):
            edges.append({"source": i, "target": j})
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 212μs -> 10.2μs (1987% faster)

def test_large_graph_with_many_properties():
    """Test with nodes containing many properties (performance check)."""
    nodes = [
        {
            "id": i,
            "label": f"Node_{i}",
            "x": i * 10,
            "y": i * 20,
            "type": "process" if i % 2 == 0 else "decision",
            "color": "red" if i % 3 == 0 else "blue",
            "size": 10 + i,
            "metadata": {"index": i, "computed": i ** 2}
        }
        for i in range(100)
    ]
    edges = [
        {
            "source": i,
            "target": i + 1,
            "weight": i,
            "label": f"e_{i}",
            "color": "green"
        }
        for i in range(99)
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 236μs -> 8.88μs (2565% faster)

def test_large_graph_binary_tree_structure():
    """Test binary tree structure with 127 nodes (2^7 - 1)."""
    # Complete binary tree: node i has children 2*i+1 and 2*i+2
    nodes = [{"id": i} for i in range(127)]
    edges = []
    for i in range(63):  # Internal nodes
        edges.append({"source": i, "target": 2 * i + 1})
        edges.append({"source": i, "target": 2 * i + 2})
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 187μs -> 8.25μs (2168% faster)

def test_large_graph_with_many_isolated_nodes():
    """Test with 200 nodes but only a small subgraph connected."""
    nodes = [{"id": i} for i in range(200)]
    # Only connect first 5 nodes
    edges = [
        {"source": 0, "target": 1},
        {"source": 1, "target": 2},
        {"source": 2, "target": 3},
        {"source": 3, "target": 4}
    ]
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 3.29μs -> 1.92μs (71.8% faster)

def test_large_random_dag_structure():
    """Test with a larger DAG (directed acyclic graph) structure."""
    # Create nodes 0-99
    nodes = [{"id": i} for i in range(100)]
    # Create edges where source < target (ensures DAG)
    edges = []
    for i in range(0, 99, 2):
        edges.append({"source": i, "target": i + 1})
    for i in range(0, 97, 3):
        edges.append({"source": i, "target": i + 2})
    codeflash_output = find_last_node(nodes, edges); result = codeflash_output # 5.75μs -> 5.17μs (11.3% 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-mluqtdmv and push.