Skip to content
Related Articles

Related Articles

Number of levels having balanced parentheses in a Binary Tree
  • Last Updated : 03 Mar, 2021

Given a Binary Tree consisting only ‘(‘ and ‘)’ a level is considered to be balanced if the nodes of the level having parenthesis are balanced from left to right. The task is to count the total number of balanced levels in a binary tree.

Examples: 

Input:          (
                  /   \
                (       )
              /  \      \
            (      )      (
          /  \    \        \
        (     (      )        ) 

Output: 2
Explanation:
In Level 2 and 4, the parenthesis are balanced.

Input:              )
                    /    \
                 (         )
                /          \
              (               )
             / 
           (              



Output: 2
Explanation:
In Level 2 and 3, the parenthesis are balanced.

Approach: Follow the steps below to solve the problem:

Below is the implementation of the above approach:

Java




// Java program for Number of levels having balanced
// parentheses in a Binary Tree
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
 
/* Class containing left and right child of current
node and key value*/
class Node {
  char key;
  Node left, right;
 
  public Node(char item)
  {
    key = item;
    left = right = null;
  }
}
 
// A Java program to introduce Binary Tree
class BinaryTree
{
 
  // Root of Binary Tree
  Node root;
 
  // Constructors
  BinaryTree(char key) { root = new Node(key); }
 
  BinaryTree() { root = null; }
 
  // Function to count levels in the
  // Binary Tree having balanced parentheses
  public static int countbal(Node root)
  {
 
    // Stores nodes of each level
    Queue<Node> que = new LinkedList<>();
    que.add(root);
 
    // Stores required count of
    // levels with balanced parentheses
    int ans = 0;
 
    // Iterate until false
    while (true)
    {
 
      // Stores parentheses
      Stack<Character> stk = new Stack<>();
      boolean flag = true;
      int len = que.size();
 
      // If length is false
      if (len == 0) {
        break;
      }
      while (len > 0)
      {
 
        // Pop 0 from queue
        // and store it in temp
        Node temp = que.remove();
 
        // Check if temp.key
        // is equal to '('
        if (temp.key == '(')
        {
 
          // push '(' into stack
          stk.push('(');
        }
        else
        {
 
          // If stk is not empty and the
          // last element in the stack is '(
          if (stk.size() > 0
              && stk.peek() == '(')
          {
 
            // Pop from stack
            stk.pop();
          }
          else
          {
 
            // Mark flag as False
            flag = false;
          }
        }
 
        // If tmp.left is True
        if (temp.left != null)
        {
 
          // push temp.left into queue
          que.add(temp.left);
        }
 
        // If tmp.right is True
        if (temp.right != null)
        {
 
          // push temp.right into queue
          que.add(temp.right);
        }
 
        // Decrement length by 1
        len--;
      }
 
      // If flag is True
      // and stk is Flase
      if (flag && stk.size() > 0)
      {
        ans += 1;
      }
    }
    return ans;
  }
 
  // Driver code
  public static void main(String[] args)
  {
    BinaryTree tree = new BinaryTree();
 
    /*create root*/
    // creating all its child
    tree.root = new Node('(');
    tree.root.left = new Node('(');
    tree.root.right = new Node(')');
    tree.root.left.left = new Node('(');
    tree.root.left.right = new Node(')');
    tree.root.right.right = new Node('(');
    tree.root.left.left.left = new Node('(');
    tree.root.left.left.right = new Node('(');
    tree.root.right.right.left = new Node(')');
    tree.root.right.right.right = new Node(')');
 
    // function call and ans print
    System.out.println(countbal(tree.root));
  }
}
 
// This code is contributed by adity7409.

Python3




# Python Code for above approach
 
# Structure of a Tree Node
class TreeNode:
    def __init__(self, val='',
                 left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
 
# Function to count levels in the
# Binary Tree having balanced parentheses
def countBal(root):
 
    # Stores nodes of each level
    que = [root]
 
    # Stores required count of
    # levels with balanced parentheses
    ans = 0
 
    # Iterate until false
    while True:
 
        # Stores parentheses
        stk = []
        flag = True
 
        length = len(que)
 
        # If length is false
        if not length:
            break
 
        while length:
 
            # Pop 0 from queue
            # and store it in temp
            temp = que.pop(0)
 
            # Check if temp.val
            # is equal to '('
            if temp.val == '(':
 
                # Append '(' into stack
                stk.append('(')
            else:
 
                # If stk is not empty and the
                # last element in the stack is '('
                if stk and stk[-1] == '(':
 
                    # Pop from stack
                    stk.pop()
                else:
 
                    # Mark flag as False
                    flag = False
 
            # If tmp.left is True
            if temp.left:
 
                # Append temp.left into queue
                que.append(temp.left)
 
            # If tmp.right is True
            if temp.right:
 
                # Append temp.right into queue
                que.append(temp.right)
 
            # Decrement length by 1
            length -= 1
 
        # If flag is True
        # and stk is Flase
        if flag and not stk:
            ans += 1
 
    # Return ans
    return ans
 
 
# Driver Code
root = TreeNode('(')
root.left = TreeNode('(')
root.right = TreeNode(')')
root.left.left = TreeNode('(')
root.left.right = TreeNode(')')
root.right.right = TreeNode('(')
root.left.left.left = TreeNode('(')
root.left.left.right = TreeNode('(')
root.right.right.left = TreeNode(')')
root.right.right.right = TreeNode(')')
 
print(countBal(root))
Output: 
2

 

Time Complexity: O(N)
Auxiliary Space: O(N)

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :