How to determine if a binary tree is height-balanced?
A tree where no leaf is much farther away from the root than any other leaf. Different balancing schemes allow different definitions of “much farther” and different amounts of work to keep them balanced.
Consider a height-balancing scheme where the following conditions should be checked to determine if a binary tree is balanced.
An empty tree is height-balanced. A non-empty binary tree T is balanced if:
- Left subtree of T is balanced
- Right subtree of T is balanced
- The difference between heights of left subtree and the right subtree is not more than 1.
The above height-balancing scheme is used in AVL trees. The diagram below shows two trees, one of them is height-balanced and other is not. The second tree is not height-balanced because height of left subtree is 2 more than height of right subtree.
To check if a tree is height-balanced, get the height of left and right subtrees. Return true if difference between heights is not more than 1 and left and right subtrees are balanced, otherwise return false.
C++
/* CPP program to check if a tree is height-balanced or not */ #include <bits/stdc++.h> using namespace std; /* A binary tree node has data, pointer to left child and a pointer to right child */ class node { public : int data; node* left; node* right; }; /* Returns the height of a binary tree */ int height(node* node); /* Returns true if binary tree with root as root is height-balanced */ bool isBalanced(node* root) { int lh; /* for height of left subtree */ int rh; /* for height of right subtree */ /* If tree is empty then return true */ if (root == NULL) return 1; /* Get the height of left and right sub trees */ lh = height(root->left); rh = height(root->right); if ( abs (lh - rh) <= 1 && isBalanced(root->left) && isBalanced(root->right)) return 1; /* If we reach here then tree is not height-balanced */ return 0; } /* UTILITY FUNCTIONS TO TEST isBalanced() FUNCTION */ /* returns maximum of two integers */ int max( int a, int b) { return (a >= b) ? a : b; } /* The function Compute the "height" of a tree. Height is the number of nodes along the longest path from the root node down to the farthest leaf node.*/ int height(node* node) { /* base case tree is empty */ if (node == NULL) return 0; /* If tree is not empty then height = 1 + max of left height and right heights */ return 1 + max(height(node->left), height(node->right)); } /* Helper function that allocates a new node with the given data and NULL left and right pointers. */ node* newNode( int data) { node* Node = new node(); Node->data = data; Node->left = NULL; Node->right = NULL; return (Node); } // Driver code int main() { node* root = newNode(1); root->left = newNode(2); root->right = newNode(3); root->left->left = newNode(4); root->left->right = newNode(5); root->left->left->left = newNode(8); if (isBalanced(root)) cout << "Tree is balanced" ; else cout << "Tree is not balanced" ; return 0; } // This code is contributed by rathbhupendra |
C
/* C program to check if a tree is height-balanced or not */ #include <stdio.h> #include <stdlib.h> #define bool int /* A binary tree node has data, pointer to left child and a pointer to right child */ struct node { int data; struct node* left; struct node* right; }; /* Returns the height of a binary tree */ int height( struct node* node); /* Returns true if binary tree with root as root is height-balanced */ bool isBalanced( struct node* root) { int lh; /* for height of left subtree */ int rh; /* for height of right subtree */ /* If tree is empty then return true */ if (root == NULL) return 1; /* Get the height of left and right sub trees */ lh = height(root->left); rh = height(root->right); if ( abs (lh - rh) <= 1 && isBalanced(root->left) && isBalanced(root->right)) return 1; /* If we reach here then tree is not height-balanced */ return 0; } /* UTILITY FUNCTIONS TO TEST isBalanced() FUNCTION */ /* returns maximum of two integers */ int max( int a, int b) { return (a >= b) ? a : b; } /* The function Compute the "height" of a tree. Height is the number of nodes along the longest path from the root node down to the farthest leaf node.*/ int height( struct node* node) { /* base case tree is empty */ if (node == NULL) return 0; /* If tree is not empty then height = 1 + max of left height and right heights */ return 1 + max(height(node->left), height(node->right)); } /* Helper function that allocates a new node with the given data and NULL left and right pointers. */ struct node* newNode( int data) { struct node* node = ( struct node*) malloc ( sizeof ( struct node)); node->data = data; node->left = NULL; node->right = NULL; return (node); } int main() { struct node* root = newNode(1); root->left = newNode(2); root->right = newNode(3); root->left->left = newNode(4); root->left->right = newNode(5); root->left->left->left = newNode(8); if (isBalanced(root)) printf ( "Tree is balanced" ); else printf ( "Tree is not balanced" ); getchar (); return 0; } |
Java
/* Java program to determine if binary tree is height balanced or not */ /* A binary tree node has data, pointer to left child, and a pointer to right child */ class Node { int data; Node left, right; Node( int d) { data = d; left = right = null ; } } class BinaryTree { Node root; /* Returns true if binary tree with root as root is height-balanced */ boolean isBalanced(Node node) { int lh; /* for height of left subtree */ int rh; /* for height of right subtree */ /* If tree is empty then return true */ if (node == null ) return true ; /* Get the height of left and right sub trees */ lh = height(node.left); rh = height(node.right); if (Math.abs(lh - rh) <= 1 && isBalanced(node.left) && isBalanced(node.right)) return true ; /* If we reach here then tree is not height-balanced */ return false ; } /* UTILITY FUNCTIONS TO TEST isBalanced() FUNCTION */ /* The function Compute the "height" of a tree. Height is the number of nodes along the longest path from the root node down to the farthest leaf node.*/ int height(Node node) { /* base case tree is empty */ if (node == null ) return 0 ; /* If tree is not empty then height = 1 + max of left height and right heights */ return 1 + Math.max(height(node.left), height(node.right)); } public static void main(String args[]) { BinaryTree tree = new BinaryTree(); tree.root = new Node( 1 ); tree.root.left = new Node( 2 ); tree.root.right = new Node( 3 ); tree.root.left.left = new Node( 4 ); tree.root.left.right = new Node( 5 ); tree.root.left.left.left = new Node( 8 ); if (tree.isBalanced(tree.root)) System.out.println( "Tree is balanced" ); else System.out.println( "Tree is not balanced" ); } } // This code has been contributed by Mayank Jaiswal(mayank_24) |
Python3
""" Python3 program to check if a tree is height-balanced """ # A binary tree Node class Node: # Constructor to create a new Node def __init__( self , data): self .data = data self .left = None self .right = None # function to find height of binary tree def height(root): # base condition when binary tree is empty if root is None : return 0 return max (height(root.left), height(root.right)) + 1 # function to check if tree is height-balanced or not def isBalanced(root): # Base condition if root is None : return True # for left and right subtree height lh = height(root.left) rh = height(root.right) # allowed values for (lh - rh) are 1, -1, 0 if ( abs (lh - rh) < = 1 ) and isBalanced( root.left) is True and isBalanced( root.right) is True : return True # if we reach here means tree is not # height-balanced tree return False # Driver function to test the above function root = Node( 1 ) root.left = Node( 2 ) root.right = Node( 3 ) root.left.left = Node( 4 ) root.left.right = Node( 5 ) root.left.left.left = Node( 8 ) if isBalanced(root): print ( "Tree is balanced" ) else : print ( "Tree is not balanced" ) # This code is contributed by Shweta Singh |
C#
using System; /* C# program to determine if binary tree is height balanced or not */ /* A binary tree node has data, pointer to left child, and a pointer to right child */ public class Node { public int data; public Node left, right; public Node( int d) { data = d; left = right = null ; } } public class BinaryTree { public Node root; /* Returns true if binary tree with root as root is height-balanced */ public virtual bool isBalanced(Node node) { int lh; // for height of left subtree int rh; // for height of right subtree /* If tree is empty then return true */ if (node == null ) { return true ; } /* Get the height of left and right sub trees */ lh = height(node.left); rh = height(node.right); if (Math.Abs(lh - rh) <= 1 && isBalanced(node.left) && isBalanced(node.right)) { return true ; } /* If we reach here then tree is not height-balanced */ return false ; } /* UTILITY FUNCTIONS TO TEST isBalanced() FUNCTION */ /* The function Compute the "height" of a tree. Height is the number of nodes along the longest path from the root node down to the farthest leaf node.*/ public virtual int height(Node node) { /* base case tree is empty */ if (node == null ) { return 0; } /* If tree is not empty then height = 1 + max of left height and right heights */ return 1 + Math.Max(height(node.left), height(node.right)); } public static void Main( string [] args) { BinaryTree tree = new BinaryTree(); tree.root = new Node(1); tree.root.left = new Node(2); tree.root.right = new Node(3); tree.root.left.left = new Node(4); tree.root.left.right = new Node(5); tree.root.left.left.left = new Node(8); if (tree.isBalanced(tree.root)) { Console.WriteLine( "Tree is balanced" ); } else { Console.WriteLine( "Tree is not balanced" ); } } } // This code is contributed by Shrikant13 |
Javascript
<script> // JavaScript program to check if a tree is height-balanced // A binary tree Node class Node{ // Constructor to create a new Node constructor(data){ this .data = data this .left = null this .right = null } } // function to find height of binary tree function height(root){ // base condition when binary tree is empty if (root == null ) return 0 return Math.max(height(root.left), height(root.right)) + 1 } // function to check if tree is height-balanced or not function isBalanced(root){ // Base condition if (root == null ) return true // for left and right subtree height let lh = height(root.left) let rh = height(root.right) // allowed values for (lh - rh) are 1, -1, 0 if (Math.abs(lh - rh) <= 1 && isBalanced( root.left)== true && isBalanced( root.right) == true ) return true // if we reach here means tree is not // height-balanced tree return false } // Driver function to test the above function let root = new Node(1) root.left = new Node(2) root.right = new Node(3) root.left.left = new Node(4) root.left.right = new Node(5) root.left.left.left = new Node(8) if (isBalanced(root)) document.write( "Tree is balanced" , "</br>" ) else document.write( "Tree is not balanced" , "</br>" ) // This code is contributed by ShinjanPatra </script> |
Output: