In a Red-Black Tree, the maximum height of a node is at most twice the minimum height (The four Red-Black tree properties make sure this is always followed). Given a Binary Search Tree, we need to check for following property.
For every node, length of the longest leaf to node path has not more than twice the nodes on shortest path from node to leaf.
12 40
\ / \
14 10 100
\ / \
16 60 150
Cannot be a Red-Black Tree It can be Red-Black Tree
with any color assignment
Max height of 12 is 1
Min height of 12 is 3
10
/ \
5 100
/ \
50 150
/
40
It can also be Red-Black Tree
Expected time complexity is O(n). The tree should be traversed at-most once in the solution.
We strongly recommend to minimize the browser and try this yourself first.
For every node, we need to get the maximum and minimum heights and compare them. The idea is to traverse the tree and for every node check if it’s balanced. We need to write a recursive function that returns three things, a boolean value to indicate the tree is balanced or not, minimum height and maximum height. To return multiple values, we can either use a structure or pass variables by reference. We have passed maxh and minh by reference so that the values can be used in parent calls.
C++
/* Program to check if a given Binary Tree is balanced like a Red-Black Tree */#include <bits/stdc++.h> using namespace std; struct Node { int key; Node *left, *right; }; /* utility that allocates a new Node with the given key */Node* newNode(int key) { Node* node = new Node; node->key = key; node->left = node->right = NULL; return (node); } // Returns returns tree if the Binary tree is balanced like a Red-Black // tree. This function also sets value in maxh and minh (passed by // reference). maxh and minh are set as maximum and minimum heights of root. bool isBalancedUtil(Node *root, int &maxh;, int &minh;) { // Base case if (root == NULL) { maxh = minh = 0; return true; } int lmxh, lmnh; // To store max and min heights of left subtree int rmxh, rmnh; // To store max and min heights of right subtree // Check if left subtree is balanced, also set lmxh and lmnh if (isBalancedUtil(root->left, lmxh, lmnh) == false) return false; // Check if right subtree is balanced, also set rmxh and rmnh if (isBalancedUtil(root->right, rmxh, rmnh) == false) return false; // Set the max and min heights of this node for the parent call maxh = max(lmxh, rmxh) + 1; minh = min(lmnh, rmnh) + 1; // See if this node is balanced if (maxh <= 2*minh) return true; return false; } // A wrapper over isBalancedUtil() bool isBalanced(Node *root) { int maxh, minh; return isBalancedUtil(root, maxh, minh); } /* Driver program to test above functions*/int main() { Node * root = newNode(10); root->left = newNode(5); root->right = newNode(100); root->right->left = newNode(50); root->right->right = newNode(150); root->right->left->left = newNode(40); isBalanced(root)? cout << "Balanced" : cout << "Not Balanced"; return 0; } |
chevron_right
filter_none
Java
// Java Program to check if a given Binary // Tree is balanced like a Red-Black Tree class GFG { static class Node { int key; Node left, right; Node(int key) { left = null; right = null; this.key = key; } } static class INT { static int d; INT() { d = 0; } } // Returns returns tree if the Binary // tree is balanced like a Red-Black // tree. This function also sets value // in maxh and minh (passed by reference). // maxh and minh are set as maximum and // minimum heights of root. static boolean isBalancedUtil(Node root, INT maxh, INT minh) { // Base case if (root == null) { maxh.d = minh.d = 0; return true; } // To store max and min heights of left subtree INT lmxh=new INT(), lmnh=new INT(); // To store max and min heights of right subtree INT rmxh=new INT(), rmnh=new INT(); // Check if left subtree is balanced, // also set lmxh and lmnh if (isBalancedUtil(root.left, lmxh, lmnh) == false) return false; // Check if right subtree is balanced, // also set rmxh and rmnh if (isBalancedUtil(root.right, rmxh, rmnh) == false) return false; // Set the max and min heights // of this node for the parent call maxh.d = Math.max(lmxh.d, rmxh.d) + 1; minh.d = Math.min(lmnh.d, rmnh.d) + 1; // See if this node is balanced if (maxh.d <= 2*minh.d) return true; return false; } // A wrapper over isBalancedUtil() static boolean isBalanced(Node root) { INT maxh=new INT(), minh=new INT(); return isBalancedUtil(root, maxh, minh); } // Driver code public static void main(String args[]) { Node root = new Node(10); root.left = new Node(5); root.right = new Node(100); root.right.left = new Node(50); root.right.right = new Node(150); root.right.left.left = new Node(40); System.out.println(isBalanced(root) ? "Balanced" : "Not Balanced"); } } // This code is contributed by Arnab Kundu |
chevron_right
filter_none
Python3
""" Program to check if a given Binary Tree is balanced like a Red-Black Tree """ # Helper function that allocates a new # node with the given data and None # left and right poers. class newNode: # Construct to create a new node def __init__(self, key): self.data = key self.left = None self.right = None # Returns returns tree if the Binary # tree is balanced like a Red-Black # tree. This function also sets value # in maxh and minh (passed by # reference). maxh and minh are set # as maximum and minimum heights of root. def isBalancedUtil(root, maxh, minh) : # Base case if (root == None) : maxh = minh = 0 return True lmxh=0 # To store max and min # heights of left subtree lmnh=0 # To store max and min # heights of right subtree rmxh, rmnh=0,0 # Check if left subtree is balanced, # also set lmxh and lmnh if (isBalancedUtil(root.left, lmxh, lmnh) == False) : return False # Check if right subtree is balanced, # also set rmxh and rmnh if (isBalancedUtil(root.right, rmxh, rmnh) == False) : return False # Set the max and min heights of # this node for the parent call maxh = max(lmxh, rmxh) + 1 minh = min(lmnh, rmnh) + 1 # See if this node is balanced if (maxh <= 2 * minh) : return True return False # A wrapper over isBalancedUtil() def isBalanced(root) : maxh, minh =0,0 return isBalancedUtil(root, maxh, minh) # Driver Code if __name__ == '__main__': root = newNode(10) root.left = newNode(5) root.right = newNode(100) root.right.left = newNode(50) root.right.right = newNode(150) root.right.left.left = newNode(40) if (isBalanced(root)): print("Balanced") else: print("Not Balanced") # This code is contributed by # Shubham Singh(SHUBHAMSINGH10) |
chevron_right
filter_none
C#
// C# Program to check if a given Binary // Tree is balanced like a Red-Black Tree using System; class GFG { public class Node { public int key; public Node left, right; public Node(int key) { left = null; right = null; this.key = key; } } public class INT { public int d; public INT() { d = 0; } } // Returns returns tree if the Binary // tree is balanced like a Red-Black // tree. This function also sets value // in maxh and minh (passed by reference). // maxh and minh are set as maximum and // minimum heights of root. static bool isBalancedUtil(Node root, INT maxh, INT minh) { // Base case if (root == null) { maxh.d = minh.d = 0; return true; } // To store max and min heights of left subtree INT lmxh = new INT(), lmnh = new INT(); // To store max and min heights of right subtree INT rmxh = new INT(), rmnh = new INT(); // Check if left subtree is balanced, // also set lmxh and lmnh if (isBalancedUtil(root.left, lmxh, lmnh) == false) return false; // Check if right subtree is balanced, // also set rmxh and rmnh if (isBalancedUtil(root.right, rmxh, rmnh) == false) return false; // Set the max and min heights // of this node for the parent call maxh.d = Math.Max(lmxh.d, rmxh.d) + 1; minh.d = Math.Min(lmnh.d, rmnh.d) + 1; // See if this node is balanced if (maxh.d <= 2 * minh.d) return true; return false; } // A wrapper over isBalancedUtil() static bool isBalanced(Node root) { INT maxh = new INT(), minh = new INT(); return isBalancedUtil(root, maxh, minh); } // Driver code public static void Main(String []args) { Node root = new Node(10); root.left = new Node(5); root.right = new Node(100); root.right.left = new Node(50); root.right.right = new Node(150); root.right.left.left = new Node(40); Console.WriteLine(isBalanced(root) ? "Balanced" : "Not Balanced"); } } // This code contributed by Rajput-Ji |
chevron_right
filter_none
Output:
Balanced
Time Complexity: Time Complexity of above code is O(n) as the code does a simple tree traversal.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
Recommended Posts:
- How to determine if a binary tree is height-balanced?
- Count Balanced Binary Trees of Height h
- Practice questions on Height balanced/AVL Tree
- Check if the Binary Tree contains a balanced BST of size K
- Shortest path between two nodes in array like representation of binary tree
- Sum of specially balanced nodes from a given Binary Tree
- Maximum height of the binary search tree created from the given array
- Count balanced nodes present in a binary tree
- Create Balanced Binary Tree using its Leaf Nodes without using extra space
- Iterative Method to find Height of Binary Tree
- Find Height of Binary Tree represented by Parent array
- Relationship between number of nodes and height of binary tree
- Height of a complete binary tree (or Heap) with N nodes
- Calculate height of Binary Tree using Inorder and Level Order Traversal
- Find height of a special binary tree whose leaf nodes are connected
- Height of binary tree considering even level leaves only
- Print the nodes of the Binary Tree whose height is a Prime number
- Print middle level of perfect binary tree without finding height
- Check whether a given binary tree is skewed binary tree or not?
- Merge Two Balanced Binary Search Trees
