Tree Terminology Root Leaf Height Depth Level in DSA Typescript - Execution Trace

Concept Flow - Tree Terminology Root Leaf Height Depth Level

Start at Root Node

↓

Check if Node has Children

Yes No↓

Go to Child

↓

Calculate Height

↓

Calculate Depth

↓

Assign Level

↓

Repeat for all Nodes

↓

End

This flow shows how to identify root, leaf nodes and calculate height, depth, and level for each node in a tree.

Execution Sample

DSA Typescript

class TreeNode {
  value: number;
  children: TreeNode[] = [];
  constructor(value: number) { this.value = value; }
}

Defines a simple tree node with a value and children array.

Execution Table

Step	Node	Is Root?	Is Leaf?	Depth	Height	Level
1	A	Yes	No	0	2	0
2	B	No	No	1	1	1
3	D	No	Yes	2	0	2
4	E	No	Yes	2	0	2
5	C	No	Yes	1	0	1
6	End	-	-	-	-	-

💡 All nodes processed; root identified; leaves found; depth, height, and level assigned.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	Final
Node	None	A	B	D	E	C	All nodes visited
Is Root?	N/A	Yes	No	No	No	No	Set for all nodes
Is Leaf?	N/A	No	No	Yes	Yes	Yes	Set for all leaves
Depth	N/A	0	1	2	2	1	Assigned per node
Height	N/A	2	1	0	0	0	Calculated bottom-up
Level	N/A	0	1	2	2	1	Same as depth here

Key Moments - 3 Insights

Why is the root node's depth 0 but height 2?

Depth counts edges from root down, so root is 0. Height counts edges from node down to deepest leaf, so root has height 2 (see execution_table step 1).

How do we know a node is a leaf?

A leaf has no children. In the table, nodes D, E, and C have 'Is Leaf?' as Yes because they have no children (steps 3,4,5).

Are level and depth always the same?

In this example, yes. Level is often defined as depth from root, so they match here (see variable_tracker Level and Depth rows).

Visual Quiz - 3 Questions

Look at the execution table, what is the height of node B at step 2?

A 1

B 0

C 2

D 3

💡 Hint

Check the 'Height' column for step 2 in the execution_table.

At which step does the node become identified as a leaf?

A Step 2

B Step 3

C Step 1

D Step 5

💡 Hint

Look for 'Is Leaf?' marked Yes in the execution_table.

If node C had children, how would its 'Is Leaf?' value change in the table?

A It would stay Yes

B It would become Root

C It would change to No

D It would have depth 0

💡 Hint

Leaves have no children, so adding children changes 'Is Leaf?' to No (see key_moments explanation).

Concept Snapshot

Tree Terminology Quick Reference:
- Root: top node, depth 0
- Leaf: node with no children
- Depth: edges from root to node
- Height: edges from node to deepest leaf
- Level: often same as depth
Use these to understand tree structure clearly.

Full Transcript

This visual execution traces tree terminology concepts. We start at the root node, which has depth 0 and height equal to the longest path to a leaf. Nodes with no children are leaves. Depth counts edges from root down, height counts edges from node down to deepest leaf. Level is often the same as depth. The execution table shows each node's properties step by step. Variable tracker records changes as we visit nodes. Key moments clarify common confusions like why root depth is zero but height is not, how leaves are identified, and the relation between level and depth. The quiz tests understanding by referencing the execution table and variable tracker. This helps beginners see how tree terms apply in practice.

Practice

1. In a tree data structure, which node is called the root?

easy

A. A node with no children

B. The topmost node with no parent

C. Any node at the bottom level

D. A node with exactly two children

Solution

1. Step 1: Understand the root node definition

   The root node is the starting point of a tree and has no parent node above it.

2. Step 2: Compare options with definition

   The topmost node with no parent matches the definition exactly. Other options describe leaf nodes or specific child counts.

3. Final Answer:

   The topmost node with no parent -> Option B

4. Quick Check:

   Root = topmost node with no parent [OK]

Hint: Root is always the top node without a parent [OK]

Common Mistakes:

• Confusing root with leaf node
• Thinking root must have children
• Assuming root is at the bottom

2. Which of the following is the correct TypeScript syntax to define a simple tree node interface with a value and children array?

easy

A. interface TreeNode { value: number; children: TreeNode[]; }

B. interface TreeNode { value: number; children: TreeNode; }

C. interface TreeNode { value: number; children: number[]; }

D. interface TreeNode { value: number; child: TreeNode[]; }

Solution

1. Step 1: Check correct property names and types

   The children property should be an array of TreeNode objects, so type is TreeNode[].

2. Step 2: Validate each option

   interface TreeNode { value: number; children: TreeNode[]; } correctly uses 'children: TreeNode[]'. interface TreeNode { value: number; children: TreeNode; } uses single TreeNode, not array. interface TreeNode { value: number; children: number[]; } uses number array incorrectly. interface TreeNode { value: number; child: TreeNode[]; } uses wrong property name 'child'.

3. Final Answer:

   interface TreeNode { value: number; children: TreeNode[]; } -> Option A

4. Quick Check:

   Children is array of TreeNode objects [OK]

Hint: Children property must be an array of TreeNode [OK]

Common Mistakes:

• Using singular 'child' instead of 'children'
• Setting children as single object, not array
• Using wrong type like number[] for children

3. Given the following tree structure in TypeScript, what is the height of the tree?

const tree = {
  value: 1,
  children: [
    { value: 2, children: [] },
    { value: 3, children: [
      { value: 4, children: [] }
    ] }
  ]
};

medium

A. 1

B. 4

C. 3

D. 2

Solution

1. Step 1: Understand height definition

   Height is the longest path from root to any leaf node, counting edges.

2. Step 2: Trace longest path in given tree

   Root (1) to node (3) to node (4) is longest path with 2 edges, so height = 2. Counting nodes gives 3 levels, but height counts edges, so height = 2.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Height = longest edge count from root to leaf = 2 [OK]

Hint: Height counts edges, not nodes, from root to deepest leaf [OK]

Common Mistakes:

• Counting nodes instead of edges for height
• Confusing height with depth
• Ignoring deeper branches

4. Consider this TypeScript code snippet for calculating the depth of a node in a tree. Identify the bug:

function getDepth(node: TreeNode, root: TreeNode, depth = 0): number {
  if (node === root) return depth;
  return getDepth(node, root.children[0], depth + 1);
}

medium

A. It always checks only the first child, missing other branches

B. It never increments depth

C. It compares node and root incorrectly

D. It should return depth + 1 instead of depth

Solution

1. Step 1: Analyze recursive call logic

   The function always calls getDepth on root.children[0], ignoring other children, so it misses nodes not in first child's subtree.

2. Step 2: Understand impact on depth calculation

   This causes incorrect depth for nodes not in first child's branch, as they are never reached.

3. Final Answer:

   It always checks only the first child, missing other branches -> Option A

4. Quick Check:

   Recursion must explore all children, not just first [OK]

Hint: Check if recursion covers all children, not just one [OK]

Common Mistakes:

• Assuming single child covers whole tree
• Not handling multiple branches in recursion
• Confusing depth increment logic

5. You have a tree where each node has a level property indicating its distance from the root (root level = 0). If a node has level 3, what is its depth and height relative to the root?

hard

A. Depth = 0, Height = 3

B. Depth = 3, Height = 3

C. Depth = 3, Height depends on subtree size

D. Depth and Height both equal to 0

Solution

1. Step 1: Understand level and depth relation

   Level and depth both measure distance from root, so depth = level = 3.

2. Step 2: Understand height meaning

   Height is longest path from node down to leaf, which depends on subtree size, so height is unknown from level alone.

3. Final Answer:

   Depth = 3, Height depends on subtree size -> Option C

4. Quick Check:

   Depth = level; height varies by subtree [OK]

Hint: Level = depth; height depends on node's subtree [OK]

Common Mistakes:

• Confusing height with depth or level
• Assuming height equals level always
• Ignoring subtree size for height