Height of Binary Tree in DSA Typescript - Execution Trace

Concept Flow - Height of Binary Tree

Start at root node

↓

Is node null?

Yes→Return 0

No↓

Find height of left subtree

↓

Find height of right subtree

↓

Height = max(left, right) + 1

↓

Return height

We start at the root and recursively find the height of left and right subtrees. The height of the node is the maximum of these two heights plus one.

Execution Sample

DSA Typescript

function height(node: TreeNode | null): number {
  if (node === null) return 0;
  const leftHeight = height(node.left);
  const rightHeight = height(node.right);
  return Math.max(leftHeight, rightHeight) + 1;
}

This function calculates the height of a binary tree by recursively finding the height of left and right children and returning the maximum plus one.

Execution Table

Step	Operation	Node Visited	Left Height	Right Height	Height Computed	Tree State
1	Start at root	A	-	-	-	A / \ B C / / \ D E F
2	Go left	B	-	-	-	B / D
3	Go left	D	-	-	-	D (leaf)
4	Left child null	null	0	-	-	-
5	Right child null	null	-	0	-	-
6	Compute height at D	D	0	0	1	D (height=1)
7	Right child null of B	null	-	0	-	-
8	Compute height at B	B	1	0	2	B (height=2)
9	Go right	C	-	-	-	C / \ E F
10	Go left	E	-	-	-	E (leaf)
11	Left child null	null	0	-	-	-
12	Right child null	null	-	0	-	-
13	Compute height at E	E	0	0	1	E (height=1)
14	Go right	F	-	-	-	F (leaf)
15	Left child null	null	0	-	-	-
16	Right child null	null	-	0	-	-
17	Compute height at F	F	0	0	1	F (height=1)
18	Compute height at C	C	1	1	2	C (height=2)
19	Compute height at A	A	2	2	3	A (height=3)
20	Return final height	A	2	2	3	Tree height = 3

💡 All nodes visited, heights computed bottom-up, final height returned at root.

Variable Tracker

Variable	Start	After Step 6	After Step 8	After Step 13	After Step 17	After Step 18	Final
node	A	D	B	E	F	C	A
leftHeight	-	0	1	0	0	1	2
rightHeight	-	0	0	0	0	1	2
height	-	1	2	1	1	2	3

Key Moments - 3 Insights

Why do we return 0 when the node is null?

Returning 0 for a null node means the height of an empty subtree is zero, as shown in steps 4, 5, 11, 12, 15, and 16 in the execution_table.

Why do we add 1 after taking the max of left and right heights?

Adding 1 accounts for the current node's level, as seen in steps 6, 8, 13, 17, 18, and 19 where height is max(leftHeight, rightHeight) + 1.

How does the recursion ensure all nodes are visited?

The recursion visits left and right children before computing height at the current node, demonstrated by the bottom-up order in the execution_table from leaves (D, E, F) to root (A).

Visual Quiz - 3 Questions

Look at the execution_table, what is the height computed at node B (step 8)?

A 1

B 2

C 3

D 0

💡 Hint

Check the 'Height Computed' column at step 8 in the execution_table.

At which step does the recursion return height 1 for leaf node E?

A Step 11

B Step 17

C Step 13

D Step 6

💡 Hint

Look for node E and height 1 in the execution_table rows.

If node F had a left child, how would the final height of the tree change?

A It would increase by 1

B It would stay the same

C It would decrease

D It would become 0

💡 Hint

Consider how adding a child increases subtree height, affecting the max height at ancestors.

Concept Snapshot

Height of Binary Tree:
- Height is max height of left and right subtree + 1
- Null node height = 0
- Use recursion to find left and right heights
- Return max(leftHeight, rightHeight) + 1
- Base case: node == null returns 0

Full Transcript

The height of a binary tree is found by starting at the root and recursively finding the height of its left and right subtrees. If a node is null, the height is zero. For each node, the height is the maximum of the left and right subtree heights plus one for the current node. This process continues bottom-up until the root's height is computed. The example tree has height 3, as shown by the step-by-step execution where leaf nodes have height 1, their parents have height 2, and the root has height 3.