The candidate has 3+5=8 edges. The returned height is 1+max(3,5)=6 nodes. Returning the full two-branch candidate as a height would let an ancestor build a branching object rather than a simple path.

def diameter(root):
    longest = 0
    def height(node):
        nonlocal longest
        if node is None:
            return 0
        _, left, right = node
        left_height = height(left)
        right_height = height(right)
        longest = max(longest, left_height + right_height)
        return 1 + max(left_height, right_height)
    height(root)
    return longest

tree = (1, (2, (4, None, None), (5, None, None)), (3, None, None))
assert diameter(tree) == 3
assert diameter((1, None, None)) == 0
assert diameter(None) == 0

Every simple tree path has a highest node relative to the chosen root, where its two downward portions meet. Considering the sum of the deepest two branches at every node includes an optimal path. The optimal path need not pass through the root.

Each node’s height is computed once: O(n) time and O(h) stack space. A slower approach that recomputes subtree heights independently at every node can take O(n²) on a chain.

Instead of a nonlocal best value, a function could return (height,best_diameter_in_subtree) and combine both child summaries. That design makes all output explicit at the cost of a larger return contract. Both are valid; choose the version you can explain and verify clearly.

Analogy limit: node count, edge count, and weighted path cost are different quantities. The left_height + right_height expression works here because height counts nodes below the current node while diameter counts connecting edges.

No. Return the best downward weighted distance, including each connecting edge’s weight, and combine the best two weighted branches. The summary-and-candidate distinction remains useful even though the measured quantity changes.