isSameTree(p, q) is defined by one sentence: it returns True exactly when the subtree at p and the subtree at q have the same shape and the same values. The code only has to keep that sentence true for one call, and the sentence then holds for every call.

Two missing nodes are two empty subtrees, and two empty subtrees are the same. So return p is None and q is None gives True there. One missing node and one real node cannot be the same, because one subtree has a node where the other has none. The same line gives False. For two real nodes, the subtrees are the same exactly when the two values are equal, the left subtrees are the same and the right subtrees are the same. The two child calls answer the last two parts, so the call only compares the two values.

Take p = [1, 2, 3, 4] and q = [1, 2, 3, null, 4]. In both trees the node 4 hangs under the node 2. It is the left child in p and the right child in q. The call on the pair (2, 2) makes two calls: the pair (4, None) and the pair (None, 4). Each pair has one missing node and returns False. So the pair (2, 2) returns False, even though its two values are equal. The pair (3, 3) returns True. The call on the roots receives False and True, and returns False.

The walk makes 7 calls in all: 5 calls on pairs where at least one node exists, and 2 calls below the pair (3, 3), where both nodes are missing. The two trees have the same preorder list of values, [1, 2, 4, 3]. A comparison of the two lists would answer True. The walk answers False because it compares positions.

The card's walk pairs p.left with q.left and p.right with q.right. That is one choice. The rest of the walk is the same for every problem on this card: a base case for a pair with a missing node, two calls on child pairs, and a combine step. Only the pairing and the combine change.

Symmetric Tree (LC 101) crosses the pairs. A mirror pairs the outer nodes and the inner nodes, so the walk starts on the root's two children and calls is_mirror(a.left, b.right) and is_mirror(a.right, b.left). In the card's template this is mirror=True. For root = [1, 2, 2, null, 3, null, 3] the answer is False: the left 2 has only a right child, and the right 2 has only a right child, so the right child of the left 2 faces a missing node. Pairing the same side instead answers True for this tree.

Merge Two Binary Trees (LC 617) builds a tree. When one node of a pair is missing, the base case returns the node that exists, a or b, and that whole branch joins the result. The combine builds TreeNode(a.val + b.val, left, right). For root1 = [1, 3, 2, 5] and root2 = [2, 1, 3, null, 4, null, 7] the result is [3, 4, 5, 5, 4, null, 7]. If the base case returned None for a pair with one missing node, as Same Tree does, the result would shrink to [3, 4, 5], because every branch that exists in only one tree would be lost.

Flip Equivalent Binary Trees (LC 951) accepts either pairing at every node. The combine tries the same side first and the crossed pairs second: the same-side pairs both match, or the crossed pairs both match. The node values are unique in this problem. For that reason only one of the two pairings can match the child values, and the other fails after one comparison. The cost stays at O(min(N, M)).

Subtree of Another Tree (LC 572) asks whether subRoot appears inside root. Run the card's walk on the pair (node, subRoot) for every node of root, and stop at the first True. The walk is the check. The outer loop is an ordinary tree walk.

The check needs the full base case. Suppose the walk returned True as soon as subRoot was used up. Then root = [3, 4, 5, 1, 2, null, null, null, null, 0] would match subRoot = [4, 1, 2], because the subtree of the node 4 starts with 4, 1, 2. But the node 2 in root has an extra child 0, so the answer is False. With the card's base case, the pair (0, None) returns False, and the extra node is seen.

The cost is O(N * M) in the worst case. The walk runs at each of the N nodes of root, and it never goes past the smaller tree, so one walk costs at most O(M), where M is the number of nodes in subRoot. Giving every distinct subtree an id lets one pass answer the question, but it needs a different idea and is not part of this card.

A call on a pair where both nodes exist makes two more calls. A call on a pair with a missing node makes none. So the number of calls is at most 2 * min(N, M) + 1. For two identical trees of 7 nodes it is exactly 15. Each call does constant work, so the time is O(min(N, M)).

The recursion goes down only while both nodes exist. The stack holds at most one frame per level of the shallower tree, so the space is O(H), where H is the height of the shallower tree.

The blueprint calls both children before it compares the values. A difference at the root therefore does not stop the walk. A version that returns False as soon as p.val != q.val stops earlier on trees that differ near the root. The worst case is the same, because two identical trees must be walked to the end.

A chain of 1000 nodes goes past Python's default limit of about 1000 nested calls. The explicit-stack version keeps the pairs on its own list. It starts with stack = [(p, q)], pops a pair, returns False on a mismatch, and pushes (a.left, b.left) and (a.right, b.right).