二叉树中具有平衡括号的级别数

给定仅包含“(”和“)”的二叉树，如果具有括号的级别的节点从左到右是平衡的，则该级别被认为是平衡的。任务是计算二叉树中平衡级别的总数。

例子：

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.

方法：请按照以下步骤解决问题：

• 初始化队列以在给定的二叉树上执行杠杆顺序遍历。
• 初始化堆栈以检查每个级别，括号是否平衡。
• 遍历每个级别并执行以下步骤：
  • 如果当前节点值为‘(’ ，则将其推入堆栈。
  • 如果当前节点值为‘)’ ，则检查堆栈是否为空。如果非空且堆栈顶部为‘(’ ，则将其从堆栈中弹出。
  • 否则，得出的结论是括号不平衡。
• 并且在遍历结束时，如果发现堆栈为空，则得出括号是平衡的结论。否则，得出的结论是括号不平衡。

下面是上述方法的实现：

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

输出：

2

时间复杂度： O(N)
辅助空间： O(N)