Find if Binary Tree Satisfies Balanced Height Property

A height-balanced binary tree generally appears to be the one in which the right subtree and the left subtree of any given node do not change or predicate by more than one, and also it focuses on the fact that both the subtrees are height-balanced.

To identify whether the given binary tree satisfies the height-balanced property, we need to check whether the heights of the left and the right subtree differ at least by one. To find out about this, we have an algorithm approach:

The very first thing we need to do is to explain a function named "is balanced" that will immediately take a binary tree node as an input and have to return a Boolean value.
If, by any chance, the input node appears to be empty, then we have to return the actual value since an empty tree is always height-balanced.
Now we have to calculate the height of the left subtree by calling out the function "is balanced" on the left child, and then we have to store that in the left height.
Now we have to calculate the height of the right subtree by calling out the function "is balanced" on the left child and then store that in the right height.
Now, we have to calculate the difference between the left and right subtree, and if it appears to be more than one, then we have to return the false value as the tree disobeys the height-balanced property.
If the above condition doesn't turn out to be true, we have to return the true value.

Implementation

/* Creating a C++ program to help us check whether the tree is height-balanced? */

#include <bits/stdc++.h>
using namespace std;

/* Data and pointers to the left and right children make up a binary tree.*/
class __nod {
public:
	int record;
	__nod* Lft;
	__nod* Rt;
	__nod(int d)
	{
		int record = d;
		Lft = Rt = NILL;
	}
};

// We should start by developing a binary tree height evaluation function 
int height(__nod* __nod)
{
	//The basic case tree in the binary tree is empty
	if (__nod == NILL)
		return 0;

	//When the tree is not empty, its height equals 1 + the maximum of its left and right sides.
	return 1 + max(height(__nod->Lft), height(__nod->Rt));
}

// We must return true if the binary tree with the roots is height-balanced. 
bool isBalanced(__nod* root)
{
	//Evaluating the height of the left subtree
	int lh;

	//Evaluating the height of the right tree
	int rh;

	// In case the tree is empty, then we have to return the value of true
	if (root == NILL)
		return 1;

	// Eventually, we have to get the heights of the left and right subtrees
	lh = height(root->Lft);
	rh = height(root->Rt);

	if (abs(lh - rh) <= 1 && imbalanced(root->Lft)
		&& isBalanced(root->Rt))
		return 1;

	// In case this pops up, then the tree is not height balanced
	return 0;
}

// Testing the above functions requires writing the main program.
int main()
{
	__nod* root = new __nod(1);
	root->Lft = new __nod(2);
	root->Rt = new __nod(3);
	root->Lft->Lft = new __nod(4);
	root->Lft->Rt = new __nod(5);
	root->Lft->Lft->Lft = new __nod(8);

	if (isBalanced(root))
		cout << "Tree is balanced";
	else
		cout << "Tree is not balanced";
	return 0;
}

Output:

Find if Binary Tree Satisfies Balanced Height Property

A step-by-step explanation of the code

Code begins by including the necessary header files, including bits/stdc++.h> containing all standard C++ libraries.
Several classes are defined in the code, including Node, which represents a binary node. Among the nodes are integer values (data) and pointers to the left and right children (left and right).
To calculate the height of a tree, the height function is defined. A node pointer (node) is input, and the tree's height rooted at that node is returned as an integer. In the case of an empty tree, the height is considered to be zero if the node is NULL. If not, the height is calculated as one plus the maximum left and right subtrees.
An isBalanced function determines whether a binary tree is height-balanced. It will take a root node value as an input and return a boolean value.
With the isbalanced function, we get two variables, lh and rh, and then store the height of both subtrees.
Now, we will have a function to check whether the absolute difference between the two heights is less than or equal to 1. If this condition is satisfied, and both the subtrees are height balanced, then we have to return the actual value.
If the above conditions are not satisfied, we must return the false value as the subtrees are not height-balanced.
Next, the primary function typically serves as the entry gate of the program.
After this, it calls the isbalanced function to verify the argument and print the results based on the returned Boolean value.
Finally, the main function returns 0, which emphasizes the complete execution of the program.

Example 2)

/* Creating a Java program that will help us check whether the tree is height-balanced or not? */
/* Data and pointers to the left and right children make up a binary tree.*/
class __nod {
	int record;
	__nod Lft, Rt;
	__nod(int d)
	{
		record = d;
		Lft = Rt = NILL;
	}
}

class BinaryTree {
	__nod root;

	/* Returns true if a binary tree with root as root is
	* height-balanced */
	boolean isBalanced(__nod __nod)
	{
	//Evaluating the height of the left subtree
		int lh; 
	//Evaluating the height of the right tree
		int rh; 
	// In case the tree is empty, then we have to return the value of true
		if (__nod == NILL)
			return true;
	// Eventually, we have to get the heights of the left and right subtrees
		lh = height(__nod.Lft);
		rh = height(__nod.Rt);

		If (Math.abs(lh - rh) <= 1 && isBalanced(__nod.Lft)
			&& isBalanced(__nod.Rt))
			return true;

	// In case this pops up, then the tree is not height balanced
		return false;
	}

// Creating a function that will evaluate the height of the binary tree
	int height(__nod __nod)
	{
	//The basic case tree in the binary tree is empty
		if (__nod == NILL)
			return 0;

	//When the tree is not empty, its height equals 1 + the maximum of its left and right sides.
		return 1
			+ Math.max(height(__nod.Lft),
					height(__nod.Rt));
	}

	public static void main(String args[])
	{
		BinaryTree tree = new BinaryTree();
		tree.root = new __nod(1);
		tree.root.Lft = new __nod(2);
		tree.root.Rt = new __nod(3);
		tree.root.Lft.Lft = new __nod(4);
		tree.root.Lft.Rt = new __nod(5);
		tree.root.Lft.Lft.Lft = new __nod(8);

		if (tree.isBalanced(tree.root))
			System.out.println("Tree is balanced");
		else
			System.out.println("Tree is not balanced");
	}
}

Output:

A step-by-step explanation of the code

The code starts by declaring two classes, 'node' and 'binary tree'. Here the node class represents the node in the binary tree and consists of a pointer to the left and right child, whereas the binary tree represents the binary tree and only has one property called the 'root'.
We have an isbalanced function in the binary tree, which takes a node as an argument and returns a boolean value.
The isbalanced function starts by checking whether the node is NULL; if it is, it represents an empty tree.
If the tree is not empty, we have to start by calculating the left and right subtrees using the height method.
The height method will calculate the height of the binary tree. If the node appears to be NULL, then we have to consider the height of the binary tree as 0. The tree's height is 1 + the maximum height between the left and right subtrees.
After we finish the calculations, the isbalanced function checks whether the height between the left and right subtree is less than 1.
If all the above-stated conditions are met, the method returns the actual value as the tree is balanced, and if not, it returns the value false.
Now, in the primary method of the function, a tree is created in the program with all the specified values for the root and the children.
Finally, the isbalanced function is called on to the tree's object 'root' to verify whether the tree is balanced.

Example 3)

/* Creating a Python program to help us check whether the tree is height-balanced? */
# Creating a brand-new binary tree node


class __nod:
	# Creating a constructor that will create a new binary tree node
	def __init__(self, record):
		self.record = record
		self.Lft = None
		self.Rt = None

# We should start by developing a binary tree height evaluation function  
def height(root):

	# recording the basic condition when the tree appears to be empty
	If the root is None:
		return 0
	return max(height(root.Lft), height(root.Rt)) + 1

# Creating a function to check whether the tree is height-balanced or not.
def isBalanced(root):

	# Writing the basic condition
	If the root is None:
		return True

	# Evaluating the height of the left subtree and right subtree
	lh = height(root.Lft)
	rh = height(root.Rt)

	# allowed values for (lh - rh) are 1, -1, 0
	if (abs(lh - rh) <= 1) and isBalanced(
			root.Lft) is True and isBalanced(root.Rt) is True:
		return True
	// In case this pops up, then the tree is not height balanced
	return False
// Testing the above functions requires writing the main program.
root = __nod(1)
root.Lft = __nod(2)
root.Rt = __nod(3)
root.Lft.Lft = __nod(4)
root.Lft.Rt = __nod(5)
root.Lft.Lft.Lft = __nod(8)
if isBalanced(root):
	print("Tree is balanced")
Else:
	print("Tree is not balanced")

Output:

A step-by-step explanation of the code

We will start by defining a class in the program named 'Node'. Here the node class represents the node in the binary tree and consists of a pointer to the left and right child.
Now, we will define a function called height(root) that will calculate the height of the binary tree. The function will use recursion to determine the binary tree's height. The primary case will be when the height of the binary tree is 0. The tree's height is 1 + maximum between the left and right subtrees.
We have to define a function called isbalanced which verifies whether a tree is height-balanced; the isbalanced function checks whether the height between the left and right subtree is less than 1. 7. If all the above-stated conditions are met, the method returns the value actual as the tree is balanced, and if not, it returns the value false.
Now, in the primary method of the function, a tree is created in the program by creating nodes and using the left and right attributes.
The isbalanced function will be called with the tree's root as an argument and return a value based on that.
Finally, based on the value returned, we will print whether the tree is balanced.

Conclusion

The code in the above approach provides a solution to check whether a tree is height-balanced. It typically defines a node class for the binary tree and various other functions to check whether a tree is height-balanced. In conclusion, the code provides a straightforward answer to the height-balanced property of the binary tree.

Next TopicFind the Largest Perfect Binary Tree in a Given Tree

← prev next →