Check if Binary Tree is Balanced in DSA C# - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean for a binary tree to be balanced?

A binary tree is balanced if for every node, the height difference between its left and right subtrees is at most 1.

beginner

Why do we check the height difference of subtrees when determining if a tree is balanced?

Because a balanced tree ensures operations like search, insert, and delete stay efficient by keeping the tree's height minimal.

intermediate

What is the time complexity of a naive approach to check if a binary tree is balanced?

The naive approach has O(n²) time complexity because it calculates height for each node repeatedly.

intermediate

How does the optimized approach improve the check for a balanced binary tree?

It calculates height and balance status in one pass using recursion, resulting in O(n) time complexity.

beginner

In C#, what data structure is commonly used to represent a binary tree node?

A class with properties for the node's value and references to left and right child nodes.

What condition must hold true for every node in a balanced binary tree?

A Tree has an even number of nodes

B Left subtree is always larger than right subtree

C All leaf nodes are at the same depth

D Height difference between left and right subtrees is at most 1

A balanced binary tree requires the height difference between left and right subtrees of every node to be at most 1.

What is the main drawback of the naive method to check if a binary tree is balanced?

A It uses too much memory

B It has O(n²) time complexity due to repeated height calculations

C It only works for complete trees

D It requires iterative traversal

The naive method recalculates heights for nodes multiple times, leading to O(n²) time complexity.

Which approach achieves O(n) time complexity when checking if a binary tree is balanced?

A Using recursion to check balance and height simultaneously

B Sorting nodes before checking

C Iterative level order traversal only

D Calculating height separately for each node

Recursion that returns both height and balance status in one pass achieves O(n) time complexity.

In C#, how do you typically represent a binary tree node?

A Struct with value and two child references

B Array of integers

C Class with value and references to left and right child nodes

D Dictionary with node values as keys

A class with properties for value and left/right child references is the common representation.

What does a height of -1 usually indicate in a balanced tree check algorithm?

A The subtree is not balanced

B The subtree is balanced

C The node is a leaf

D The node is null

Returning -1 signals that the subtree is not balanced in the recursive check.

Explain how to check if a binary tree is balanced using a recursive approach.

Think about combining height calculation and balance check in one function.

Describe the difference between the naive and optimized methods for checking if a binary tree is balanced.

Focus on how many times height is calculated in each method.

Practice

1. What does it mean for a binary tree to be balanced?

easy

A. The height difference between left and right subtrees of every node is at most 1

B. All nodes have two children

C. The tree has the same number of nodes on left and right

D. The tree is sorted in ascending order

Solution

1. Step 1: Understand balance condition

   A balanced binary tree means the height difference between left and right subtrees of every node is at most 1.

2. Step 2: Compare other options

   Options B, C, and D describe different properties not related to balance.

3. Final Answer:

   The height difference between left and right subtrees of every node is at most 1 -> Option A

4. Quick Check:

   Balance means height difference ≤ 1 [OK]

Hint: Balance means subtree heights differ by no more than 1 [OK]

Common Mistakes:

• Confusing balanced with complete or full tree
• Thinking balance means equal number of nodes
• Assuming sorted order means balanced

2. Which C# method signature correctly represents a function that checks if a binary tree is balanced?

easy

A. public bool IsBalanced(TreeNode root)

B. bool CheckBalance(int root)

C. public int IsBalanced(TreeNode root)

D. void IsBalanced(TreeNode root)

Solution

1. Step 1: Identify correct return type and parameters

   The function should return a boolean indicating if the tree is balanced and take the root node as input.

2. Step 2: Check method signature correctness

   public bool IsBalanced(TreeNode root) matches this: public bool IsBalanced(TreeNode root). Others have wrong return types or parameter types.

3. Final Answer:

   public bool IsBalanced(TreeNode root) -> Option A

4. Quick Check:

   Return bool, input TreeNode root [OK]

Hint: Check method returns bool and takes TreeNode root [OK]

Common Mistakes:

• Using int return type instead of bool
• Passing wrong parameter type like int
• Using void return type for a check function

3. Given the following tree structure and code, what will be the output?

class TreeNode {
  public int val;
  public TreeNode left, right;
  public TreeNode(int v) { val = v; }
}

// Tree:
//     1
//    / \
//   2   3
//  /
// 4

TreeNode root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);

bool result = IsBalanced(root);
Console.WriteLine(result);

bool IsBalanced(TreeNode node) {
  if (node == null) return true;
  int leftHeight = Height(node.left);
  int rightHeight = Height(node.right);
  if (Math.Abs(leftHeight - rightHeight) > 1) return false;
  return IsBalanced(node.left) && IsBalanced(node.right);
}

int Height(TreeNode node) {
  if (node == null) return 0;
  return 1 + Math.Max(Height(node.left), Height(node.right));
}

medium

A. Runtime exception

B. false

C. Compilation error

D. true

Solution

1. Step 1: Calculate heights of subtrees

   Node 2 has left subtree height 1 (node 4) and right subtree height 0, difference is 1 (allowed). Node 1 has left height 2 and right height 1, difference is 1 (allowed).

2. Step 2: Check balance recursively

   Node 4 and 3 are leaves (balanced). However, node 2's left subtree is height 1 and right is 0, difference 1 (balanced). So all nodes satisfy balance condition.

3. Final Answer:

   true -> Option D

4. Quick Check:

   Height difference ≤ 1 at all nodes = true [OK]

Hint: Check height difference at each node recursively [OK]

Common Mistakes:

• Miscounting subtree heights
• Not checking all nodes recursively
• Assuming difference > 0 means unbalanced

4. The following code is intended to check if a binary tree is balanced. What is the bug?

bool IsBalanced(TreeNode node) {
  if (node == null) return true;
  int leftHeight = Height(node.left);
  int rightHeight = Height(node.right);
  if (Math.Abs(leftHeight - rightHeight) > 1) return false;
  return IsBalanced(node.left) || IsBalanced(node.right);
}

int Height(TreeNode node) {
  if (node == null) return 0;
  return 1 + Math.Max(Height(node.left), Height(node.right));
}

medium

A. Missing null check for node

B. Using || instead of && in recursive calls

C. Height function returns wrong value

D. Incorrect base case in IsBalanced

Solution

1. Step 1: Analyze recursive condition

   The code uses || (OR) to combine left and right subtree balance checks, which returns true if either subtree is balanced.

2. Step 2: Correct logic for balance check

   Both left and right subtrees must be balanced, so && (AND) should be used instead of ||.

3. Final Answer:

   Using || instead of && in recursive calls -> Option B

4. Quick Check:

   Balance requires both subtrees balanced, use && [OK]

Hint: Use && to combine subtree balance checks [OK]

Common Mistakes:

• Using || instead of && in recursive checks
• Ignoring base case for null nodes
• Incorrect height calculation

5. You want to optimize the check for a balanced binary tree to avoid repeated height calculations. Which approach is best?

hard

A. Calculate height first, then check balance separately

B. Use BFS to check balance level by level

C. Calculate height and balance in one recursive function returning a tuple

D. Store heights in a global dictionary and update after each insertion

Solution

1. Step 1: Understand repeated height calculation problem

   Calculating height separately for each node causes repeated work, increasing time complexity.

2. Step 2: Use combined recursive approach

   Returning both height and balance status in one recursive call avoids repeated height calculations and improves efficiency.

3. Final Answer:

   Calculate height and balance in one recursive function returning a tuple -> Option C

4. Quick Check:

   Combine height and balance in one recursion for efficiency [OK]

Hint: Return height and balance together in one recursion [OK]

Common Mistakes:

• Separating height and balance checks causing repeated work
• Using BFS which doesn't directly check balance
• Using global dictionary unnecessarily complicates code