📌  相关文章
📜  求一棵宽度为 K 的二叉树的层级

📅  最后修改于: 2021-09-04 08:39:42             🧑  作者: Mango

给定一个二叉树和一个整数K ,任务是找到宽度为K的二叉树的级别。如果存在多个宽度为K的级别,则打印最低级别。如果不存在这样的级别,则打印-1

例子:

方法:
解决问题的基本思路是为每个节点添加一个标签。如果父节点有标签i ,则将标签2*i分配给它的左孩子,将标签2*i+1分配给其右孩子。这将有助于在计算中包含 NULL 节点。
请按照以下步骤操作:

  • 使用Queue对给定的树执行层序遍历
  • 队列包含一对{Node, Label}。最初将 { rootNode, 0 } 插入队列。
  • 如果 parent 有标签 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)

如果您想与行业专家一起参加直播课程,请参阅Geeks Classes Live