给定一个二叉树和一个整数K ，任务是找到宽度为K的二叉树的级别。如果宽度K存在多个级别，请打印最低级别。如果不存在这样的级别，请打印-1 。
The width of a level of a Binary tree is defined as the number of nodes between leftmost and the rightmost node at that level, including the NULL nodes in between them as well.
例子：
Input: K = 4
Output: 3
Explanation:
For the given tree, the levels having width K( = 4) are 3 and 4.
Since 3 is the minimum of the two, print the minimum.
Input: K = 7
Output: 4
Explanation:
For the given tree, the level having width K( = 7) is 4.
方法：
解决该问题的基本思路是为每个节点添加标签。如果父项具有标签i ，则为其左孩子分配标签2 * i ，为其右孩子分配标签2 * i + 1 。这将有助于在计算中包括NULL节点。
请按照以下步骤操作：
- 使用Queue在给定的树上执行Level Order遍历。
- 队列包含一对{Node，Label}。最初插入{ rootNode，0 }进行排队。
- 如果父级具有标签i，则对于左孩子，将{ leftChild，2 * i }插入队列，对于右孩子，将{ rightChild，2 * i + 1 }插入队列。
- 对于每个级别，假定a为最左侧节点的标签， b为最右侧节点的标签，则(b-a + 1)给出该级别的宽度。
- 检查宽度是否等于K。如果是这样，则返回level 。
- 如果所有级别的宽度都不为K ，则返回-1 。
下面是上述方法的实现：
C++
5 --------- 1st level width = 1 => (5)
/ \
6 2 -------- 2nd level width = 2 => (6, 2)
/ \ \
7 3 8 -------3rd level width = 4 => (7, 3, NULL, 8)
/ \
5 4 -----------4th level width = 4 => (5, NULL, NULL, 4)Java
1 --------- 1st level width = 1 => (1)
/ \
2 9 -------- 2nd level width = 2 => (2, 9)
/ \
7 8 ---------3rd level width = 4 => (7, NULL, NULL, 8)
/ /
5 9 -----------4th level width = 7 => (5, NULL, NULL,
/ NULL, NULL, NULL, 9)
2 -----------5th level width = 1 => (2)
/
1 -----------6th level width = 1 => (1)Python3
// C++ Program to implement
// the above approach
#include
using namespace std;
// Structure of a Tree node
struct Node {
int key;
struct Node *left, *right;
};
// Utility function to create
// and initialize a new node
Node* newNode(int key)
{
Node* temp = new Node;
temp->key = key;
temp->left = temp->right = NULL;
return (temp);
}
// Function returns required level
// of width k, if found else -1
int findLevel(Node* root,
int k, int level)
{
// To store the node and the label
// and perform traversal
queue > qt;
qt.push(make_pair(root, 0));
int count = 1, b, a = 0;
while (!qt.empty()) {
pair temp = qt.front();
qt.pop();
// Taking the last label
// of each level of the tree
if (count == 1) {
b = temp.second;
}
if ((temp.first)->left) {
qt.push(make_pair(
temp.first->left,
2 * temp.second));
}
if (temp.first->right) {
qt.push(make_pair(
temp.first->right,
2 * temp.second + 1));
}
count--;
// Check width of current level
if (count == 0) {
// If the width is equal to k
// then return that level
if (b - a + 1 == k)
return level;
pair secondLabel = qt.front();
// Taking the first label
// of each level of the tree
a = secondLabel.second;
level += 1;
count = qt.size();
}
}
// If any level does not has
// width equal to k, return -1
return -1;
}
// Driver Code
int main()
{
Node* root = newNode(5);
root->left = newNode(6);
root->right = newNode(2);
root->right->right = newNode(8);
root->left->left = newNode(7);
root->left->left->left = newNode(5);
root->left->right = newNode(3);
root->left->right->right = newNode(4);
int k = 4;
cout << findLevel(root, k, 1) << endl;
return 0;
} C#
// Java program to implement
// the above approach
import java.util.*;
class GFG{
// Structure of
// binary tree node
static class Node
{
int data;
Node left, right;
};
static class pair
{
Node first;
int second;
pair(Node first, int second)
{
this.first = first;
this.second = second;
}
}
// Function to create new node
static Node newNode(int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null;
return temp;
}
// Function returns required level
// of width k, if found else -1
static int findLevel(Node root,
int k, int level)
{
// To store the node and the label
// and perform traversal
Queue qt = new LinkedList<>();
qt.add(new pair(root, 0));
int count = 1, b = 0, a = 0;
while (!qt.isEmpty())
{
pair temp = qt.peek();
qt.poll();
// Taking the last label
// of each level of the tree
if (count == 1)
{
b = temp.second;
}
if (temp.first.left != null)
{
qt.add(new pair(
temp.first.left,
2 * temp.second));
}
if (temp.first.right != null)
{
qt.add(new pair(
temp.first.right,
2 * temp.second + 1));
}
count--;
// Check width of current level
if (count == 0)
{
// If the width is equal to k
// then return that level
if ((b - a + 1) == k)
return level;
pair secondLabel = qt.peek();
// Taking the first label
// of each level of the tree
a = secondLabel.second;
level += 1;
count = qt.size();
}
}
// If any level does not has
// width equal to k, return -1
return -1;
}
// Driver code
public static void main(String[] args)
{
Node root = newNode(5);
root.left = newNode(6);
root.right = newNode(2);
root.right.right = newNode(8);
root.left.left = newNode(7);
root.left.left.left = newNode(5);
root.left.right = newNode(3);
root.left.right.right = newNode(4);
int k = 4;
System.out.println(findLevel(root, k, 1));
}
}
// This code is contributed by offbeat 输出：
# Python3 program to implement
# the above approach
from collections import deque
# Structure of a Tree node
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
# Function returns required level
# of width k, if found else -1
def findLevel(root: Node,
k: int, level: int) -> int:
# To store the node and the label
# and perform traversal
qt = deque()
qt.append([root, 0])
count = 1
b = 0
a = 0
while qt:
temp = qt.popleft()
# Taking the last label
# of each level of the tree
if (count == 1):
b = temp[1]
if (temp[0].left):
qt.append([temp[0].left,
2 * temp[1]])
if (temp[0].right):
qt.append([temp[0].right,
2 * temp[1] + 1])
count -= 1
# Check width of current level
if (count == 0):
# If the width is equal to k
# then return that level
if (b - a + 1 == k):
return level
secondLabel = qt[0]
# Taking the first label
# of each level of the tree
a = secondLabel[1]
level += 1
count = len(qt)
# If any level does not has
# width equal to k, return -1
return -1
# Driver Code
if __name__ == "__main__":
root = Node(5)
root.left = Node(6)
root.right = Node(2)
root.right.right = Node(8)
root.left.left = Node(7)
root.left.left.left = Node(5)
root.left.right = Node(3)
root.left.right.right = Node(4)
k = 4
print(findLevel(root, k, 1))
# This code is contributed by sanjeev2552时间复杂度： O(N)
辅助空间： O(N)