Tree Terminology Root Leaf Height Depth Level in DSA Python - Time & Space Complexity
When working with trees, it is important to understand how the time to do tasks grows as the tree gets bigger.
We want to know how operations like finding height or depth take longer when the tree has more nodes.
Analyze the time complexity of this code that finds the height of a binary tree.
def tree_height(node):
if node is None:
return 0
left_height = tree_height(node.left)
right_height = tree_height(node.right)
return 1 + max(left_height, right_height)
This code finds the height by checking the height of left and right subtrees recursively.
Look at what repeats as the function runs:
- Primary operation: Recursive calls to visit each node once.
- How many times: Once for every node in the tree.
As the tree grows, the function visits every node once to find height.
| Input Size (n) | Approx. Operations |
|---|---|
| 10 | About 10 visits |
| 100 | About 100 visits |
| 1000 | About 1000 visits |
Pattern observation: Operations grow directly with the number of nodes.
Time Complexity: O(n)
This means the time to find the height grows in a straight line with the number of nodes.
[X] Wrong: "The height function only checks the longest path, so it runs faster than visiting all nodes."
[OK] Correct: The function must visit every node to be sure of the longest path, so it touches all nodes anyway.
Understanding how tree operations scale helps you explain your solutions clearly and confidently in interviews.
"What if we changed the tree to be a linked list (all nodes have only one child)? How would the time complexity change?"
Practice
root?Solution
Step 1: Understand the root node definition
The root node is the starting point of the tree and has no parent node above it.Step 2: Compare options with definition
The topmost node with no parent matches this definition exactly. Other options describe leaf nodes or other properties.Final Answer:
The topmost node with no parent -> Option BQuick Check:
Root = topmost node with no parent [OK]
- Confusing root with leaf node
- Thinking root has children always
- Mixing root with internal nodes
leaf node in a tree?Solution
Step 1: Define leaf node
A leaf node is a node that has no children; it is at the end of a branch.Step 2: Match definition with options
A node with no children states a node with no children, which matches the leaf node definition.Final Answer:
A node with no children -> Option AQuick Check:
Leaf = node with no children [OK]
- Thinking leaf nodes have children
- Confusing leaf with root
- Assuming leaf nodes must have one child
A
/ \
B C
/ / \
D E F
What is the height of node C?Solution
Step 1: Understand height of a node
Height is the number of edges on the longest path from the node down to a leaf.Step 2: Calculate height of node C
Node C has children E and F, both leaves with height 0. So height of C = 1 + max(0,0) = 1.Step 3: Verify options
1 says 1, but height counts edges down, so height is 1. 2 says 2, which is incorrect. 0 is 0, which is leaf height.Final Answer:
1 -> Option DQuick Check:
Height of C = 1 edge to leaf [OK]
- Confusing height with depth
- Counting nodes instead of edges
- Assuming leaf height is 1
X
/ \
Y Z
/
W What is the
depth of node W?Note: Depth is the number of edges from the root to the node.
Solution
Step 1: Understand depth definition
Depth is the number of edges from the root node to the target node.Step 2: Trace path from root to W
Path: X (root) -> Y -> W. Number of edges = 2.Final Answer:
2 -> Option AQuick Check:
Depth of W = 2 edges from root [OK]
- Counting nodes instead of edges
- Confusing depth with height
- Starting count from 1 instead of 0
level of a node is defined as its depth plus one. Given the tree: M
/ \
N O
/ \
P Q
What is the level of node Q?Solution
Step 1: Find depth of node Q
Path from root M to Q is M -> N -> Q, which has 2 edges, so depth = 2.Step 2: Calculate level using formula
Level = depth + 1 = 2 + 1 = 3.Final Answer:
3 -> Option CQuick Check:
Level = depth + 1 = 3 [OK]
- Using depth as level directly
- Counting nodes incorrectly
- Confusing level with height
Ready to prove it?
Pass the test and this pattern moves unknown
