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 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 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