📌  相关文章
📜  二叉树中的计数级别,该二叉树由在不同位置具有置位的节点值组成

📅  最后修改于: 2021-05-25 01:29:26             🧑  作者: Mango

给定一个由N个节点组成的二叉树,任务是对二叉树中的级别数进行计数,以使同一级别上所有节点值的设置位位于不同的位置。

例子:

天真的方法:解决此问题的最简单方法是使用级别顺序遍历遍历二叉树,并在树的每个级别使用Map存储所有节点的设置位。遍历该映射,并检查同一位置的置位频率是否小于或等于1。如果发现为真,则增加计数。最后,打印获得的计数。
时间复杂度: O(N)
辅助空间: O(32)

高效的方法:可以基于以下观察来优化上述方法:

请按照以下步骤解决问题:

  • 初始化一个变量,例如prefiX_XOR ,以存储每个级别上所有节点的前缀XOR。
  • 初始化一个变量,例如prefiX_OR ,以存储每个级别上所有节点的前缀OR。
  • 使用级别顺序遍历遍历二叉树。在每个i级别,检查prefix_XOR ^节点是否等于(prefix_OR |节点) 。如果发现对于当前级别的所有节点都是正确的,则增加计数。
  • 最后,打印获得的计数。

下面是上述方法的实现:

C++14
5
              / \
             6   9
            / \   \
           1   4   7


Java
1
           / \
          2   3
         / \   \
        5   4   7


Python3
// C++ program for the above approach
#include 
 
using namespace std;
 
// Structure of a node in
// the binary tree
struct TreeNode
{
  int val = 0;
  TreeNode *left,*right;
  TreeNode(int x)
  {
        val = x;
        left = NULL;
        right = NULL;
  }
};
 
// Function to find total unique levels
void uniqueLevels(TreeNode *root)
{
 
    // Stores count of levels, where the set
    // bits of all the nodes are at
    // different positions
    int uniqueLevels = 0;
 
    // Store nodes at  each level of
    // the tree using BFS
    queue que;
    que.push(root);
 
    // Performing level order traversal
    while (que.size() > 0)
    {
 
        // Stores count of nodes at
        // current level
        int length = que.size();
 
        // Stores prefix XOR of all
        // the nodes at current level
        int prefix_XOR = 0;
 
        // Stores prefix OR of all
        // the nodes at current level
        int prefix_OR = 0;
 
        // Check if set bit of all the nodes
        // at current level is at different
        // positions or not
        bool flag = true;
 
        // Traverse nodes at current level
        for(int i = 0; i < length; i++){
 
            // Stores front element
            // of the que
            TreeNode *temp = que.front();
            que.pop();
 
            // Update prefix_OR
            prefix_OR |= temp->val;
 
            // Update prefix_XOR
            prefix_XOR ^= temp->val;
            if (prefix_XOR != prefix_OR)
                flag = false;
 
            // If left subtree not NULL
            if (temp->left)
                que.push(temp->left);
 
            // If right subtree not NULL
            if (temp->right)
                que.push(temp->right);
 
            // Update length
        }
 
        //If bitwise AND is zero
        if (flag)
            uniqueLevels += 1;
      }
    cout << uniqueLevels;
}
 
// Driver Code
int main()
{
  TreeNode *root = new TreeNode(5);
  root->left = new TreeNode(6);
  root->right = new TreeNode(9);
  root->left->left = new TreeNode(1);
  root->left->right = new TreeNode(4);
  root->right->right = new TreeNode(7);
 
  // Function Call
  uniqueLevels(root);
  return 0;
}
 
// This code is contributed by mohit kumar 29.


C#
// Java program for the above approach
import java.util.*;
class GFG
{
 
  // Structure of a node in
  // the binary tree
  static class TreeNode
  {
    int val = 0;
    TreeNode left, right;
    TreeNode(int x)
    {
      val = x;
      left = null;
      right = null;
    }
  };
 
  // Function to find total unique levels
  static void uniqueLevels(TreeNode root)
  {
 
    // Stores count of levels, where the set
    // bits of all the nodes are at
    // different positions
    int uniqueLevels = 0;
 
    // Store nodes at  each level of
    // the tree using BFS
    Queue que = new LinkedList<>();
    que.add(root);
 
    // Performing level order traversal
    while (que.size() > 0)
    {
 
      // Stores count of nodes at
      // current level
      int length = que.size();
 
      // Stores prefix XOR of all
      // the nodes at current level
      int prefix_XOR = 0;
 
      // Stores prefix OR of all
      // the nodes at current level
      int prefix_OR = 0;
 
      // Check if set bit of all the nodes
      // at current level is at different
      // positions or not
      boolean flag = true;
 
      // Traverse nodes at current level
      for(int i = 0; i < length; i++)
      {
 
        // Stores front element
        // of the que
        TreeNode temp = que.peek();
        que.remove();
 
        // Update prefix_OR
        prefix_OR |= temp.val;
 
        // Update prefix_XOR
        prefix_XOR ^= temp.val;
        if (prefix_XOR != prefix_OR)
          flag = false;
 
        // If left subtree not null
        if (temp.left != null)
          que.add(temp.left);
 
        // If right subtree not null
        if (temp.right != null)
          que.add(temp.right);
 
        // Update length
      }
 
      //If bitwise AND is zero
      if (flag)
        uniqueLevels += 1;
    }
    System.out.print(uniqueLevels);
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    TreeNode root = new TreeNode(5);
    root.left = new TreeNode(6);
    root.right = new TreeNode(9);
    root.left.left = new TreeNode(1);
    root.left.right = new TreeNode(4);
    root.right.right = new TreeNode(7);
 
    // Function Call
    uniqueLevels(root);
  }
}
 
// This code is contributed by 29AjayKumar


输出:
# Python program for the above approach
 
 
# Structure of a node in
# the binary tree
class TreeNode:
    def __init__(self, val = 0, left = None, right = None):
        self.val = val
        self.left = left
        self.right = right
 
# Function to find total unique levels
def uniqueLevels(root):
 
    # Stores count of levels, where the set
    # bits of all the nodes are at
    # different positions
    uniqueLevels = 0
 
    # Store nodes at  each level of
    # the tree using BFS
    que = [root]
 
    # Performing level order traversal
    while len(que):
     
        # Stores count of nodes at
        # current level
        length = len(que)
 
        # Stores prefix XOR of all
        # the nodes at current level
        prefix_XOR = 0;
 
        # Stores prefix OR of all
        # the nodes at current level
        prefix_OR = 0
 
        # Check if set bit of all the nodes
        # at current level is at different
        # positions or not
        flag = True
 
        # Traverse nodes at current level
        while length:
 
            # Stores front element
            # of the que
            temp = que.pop(0)
 
            # Update prefix_OR
            prefix_OR |= temp.val
 
            # Update prefix_XOR
            prefix_XOR ^= temp.val
 
            if prefix_XOR != prefix_OR:
                flag = False
             
            # If left subtree not NULL
            if temp.left:
                que.append(temp.left)
 
            # If right subtree not NULL   
            if temp.right:
                que.append(temp.right)
 
            # Update length   
            length -= 1
 
        # If bitwise AND is zero
        if flag:
            uniqueLevels += 1
 
    print(uniqueLevels)
 
# Driver Code
if __name__ == '__main__':
     
    root = TreeNode(5)
    root.left = TreeNode(6)
    root.right = TreeNode(9)
    root.left.left = TreeNode(1)
    root.left.right = TreeNode(4)
    root.right.right = TreeNode(7)
 
    # Function Call
    uniqueLevels(root)

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