Why Check if Binary Tree is Balanced in DSA Javascript?

The Big Idea

Discover how a simple trick saves you from endless measuring and guessing if a tree is balanced!

The Scenario

Imagine you have a family tree drawn on paper. You want to check if the tree looks balanced, meaning no side is too tall compared to the other. Doing this by measuring each branch manually is tiring and confusing.

The Problem

Manually checking if a tree is balanced means measuring every branch length and comparing them. This is slow, easy to make mistakes, and hard to keep track of all parts, especially for big trees.

The Solution

Using a smart method, we can check balance by looking at each node once, calculating heights, and deciding if the tree is balanced without repeating work. This saves time and avoids errors.

Before vs After

✗ Before

function isBalanced(root) {
  if (!root) return true;
  let leftHeight = height(root.left);
  let rightHeight = height(root.right);
  if (Math.abs(leftHeight - rightHeight) > 1) return false;
  return isBalanced(root.left) && isBalanced(root.right);
}

function height(node) {
  if (!node) return 0;
  return 1 + Math.max(height(node.left), height(node.right));
}

✓ After

function checkBalance(node) {
  if (!node) return 0;
  let leftHeight = checkBalance(node.left);
  if (leftHeight === -1) return -1;
  let rightHeight = checkBalance(node.right);
  if (rightHeight === -1) return -1;
  if (Math.abs(leftHeight - rightHeight) > 1) return -1;
  return 1 + Math.max(leftHeight, rightHeight);
}

function isBalanced(root) {
  return checkBalance(root) !== -1;
}

What It Enables

This method lets us quickly and reliably know if a tree is balanced, which helps keep data organized and fast to search.

Real Life Example

In computer games, balanced trees help manage objects so the game runs smoothly without delays caused by unbalanced data.

Key Takeaways

Manual checking is slow and error-prone.

Smart recursive method checks balance efficiently.

Balanced trees improve performance in many applications.