Nodes at Kth level without duplicates in a Binary Tree

Given a binary tree with N nodes and an integer K, the task is to print nodes of the Kth level of a binary tree without duplicates.

Examples:

Input:       
          60             --- Level 0
         /  \
       50    30          --- Level 1
      /  \   /
    80   10 40           --- Level 2

K = 1
Output: 30 50

Input:
           50            --- Level 0
          /  \
        60    70         --- Level 1
       /  \   / \
     90   40 40  20      --- Level 2
K = 2
Output: 20 40 90

Approach: The idea is to traverse the Binary Tree using the Level Order Traversal with the help of queue and if the Level of the Traveral is K then store all the Nodes of that Level in a Set such that there are no duplicate nodes at that level.

Algorithm:



  • Intialize an Empty Queue to store the nodes at a level.
  • Enque the Root node of the Binary Tree in the queue.
  • Intialize the Level as 0, as the first level of the tree is supposed to be 0 here.
  • Intialize the flag as 0 to check Kth level is reached or not.
  • Iterate using a while loop untill the queue is not empty.
    1. Find the size of the queue and store in a variable size to visit only the nodes of a current level.
    2. Iterate with another while loop until the size variable is not 0
    3. Deque a node from the queue and Enque its Left and right childs in the Queue.
    4. If the current level is equal to the K, then add the data of the node into the set and also set the flag.
  • If flag is set then break the loop to not visit further levels, otherwise increment the current level by 1.
  • Print the elements of the set with the help of iterator.

Explanation with Example:

Binary Tree -
           50            --- Level 0
          /  \
        60    70         --- Level 1
       /  \   / \
     90   40 40  20      --- Level 2 
K = 2

Initialize Queue and Set and append Root in queue

Step 1:
Queue = [50],  Set = {}, Level = 0

As current Level is not equal to K,
Deque nodes from the queue and enqueue its  child

Step 2:
Queue = [60, 70], Set = {}, Level = 1

As current level is not equal to K
Deque nodes one by one from the queue and enqueue its child

Step 3:
Queue = [90, 40, 40, 20], Set = {}, Level = 2

As the current level is equal to K
Deque all the nodes from the queue and add to the set

Set = {90, 40, 20}       

Below is the implementation of the approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to print the 
// nodes of Kth Level without duplicates
  
#include <bits/stdc++.h>
using namespace std;
  
// Structure of Binary Tree node
struct node {
    int data;
    struct node* left;
    struct node* right;
};
  
// Function to create new
// Binary Tree node
struct node* newNode(int data)
{
    struct node* temp = new struct node;
    temp->data = data;
    temp->left = nullptr;
    temp->right = nullptr;
    return temp;
};
  
// Function to print the nodes
// of Kth Level without duplicates
void nodesAtKthLevel(struct node* root,
                        int k){
  
    // Condition to check if current 
    // node is None
    if (root == nullptr)
        return;
          
    // Create Queue
    queue<struct node*> que;
  
    // Enqueue the root node
    que.push(root);
  
    // Create a set
    set<int> s;
  
    // Level to track
    // the current level
    int level = 0;
    int flag = 0;
  
    // Iterate the queue till its not empty
    while (!que.empty()) {
  
        // Calculate the number of nodes
        // in the current level
        int size = que.size();
  
        // Process each node of the current
        // level and enqueue their left
        // and right child to the queue
        while (size--) {
            struct node* ptr = que.front();
            que.pop();
  
            // If the current level matches the
            // required level then add into set
            if (level == k) {
  
                // Flag initialized to 1
                flag = 1;
  
                // Inserting node data in set
                s.insert(ptr->data);
            }
            else {
  
                // Traverse to the left child
                if (ptr->left)
                    que.push(ptr->left);
  
                // Traverse to the right child
                if (ptr->right)
                    que.push(ptr->right);
            }
        }
  
        // Increment the variable level
        // by 1 for each level
        level++;
  
        // Break out from the loop 
        // if the Kth Level is reached
        if (flag == 1)
            break;
    }
    set<int>::iterator it;
    for (it = s.begin(); it != s.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;
}
  
// Driver code
int main()
{
    struct node* root = new struct node;
  
    // Tree Construction
    root = newNode(60);
    root->left = newNode(20);
    root->right = newNode(30);
    root->left->left = newNode(80);
    root->left->right = newNode(10);
    root->right->left = newNode(40);
    int level = 1;
    nodesAtKthLevel(root, level);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation to print the 
// nodes of Kth Level without duplicates
import java.util.*;
  
class GFG{
   
// Structure of Binary Tree node
static class node {
    int data;
    node left;
    node right;
};
   
// Function to create new
// Binary Tree node
static node newNode(int data)
{
    node temp = new node();
    temp.data = data;
    temp.left = null;
    temp.right = null;
    return temp;
};
   
// Function to print the nodes
// of Kth Level without duplicates
static void nodesAtKthLevel(node root,
                        int k){
   
    // Condition to check if current 
    // node is None
    if (root == null)
        return;
           
    // Create Queue
    Queue<node> que = new LinkedList<node>();
   
    // Enqueue the root node
    que.add(root);
   
    // Create a set
    HashSet<Integer> s = new HashSet<Integer>();
   
    // Level to track
    // the current level
    int level = 0;
    int flag = 0;
   
    // Iterate the queue till its not empty
    while (!que.isEmpty()) {
   
        // Calculate the number of nodes
        // in the current level
        int size = que.size();
   
        // Process each node of the current
        // level and enqueue their left
        // and right child to the queue
        while (size-- > 0) {
            node ptr = que.peek();
            que.remove();
   
            // If the current level matches the
            // required level then add into set
            if (level == k) {
   
                // Flag initialized to 1
                flag = 1;
   
                // Inserting node data in set
                s.add(ptr.data);
            }
            else {
   
                // Traverse to the left child
                if (ptr.left!=null)
                    que.add(ptr.left);
   
                // Traverse to the right child
                if (ptr.right!=null)
                    que.add(ptr.right);
            }
        }
   
        // Increment the variable level
        // by 1 for each level
        level++;
   
        // Break out from the loop 
        // if the Kth Level is reached
        if (flag == 1)
            break;
    }
    for (int it : s) {
        System.out.print(it+ " ");
    }
    System.out.println();
}
   
// Driver code
public static void main(String[] args)
{
    node root = new node();
   
    // Tree Construction
    root = newNode(60);
    root.left = newNode(20);
    root.right = newNode(30);
    root.left.left = newNode(80);
    root.left.right = newNode(10);
    root.right.left = newNode(40);
    int level = 1;
    nodesAtKthLevel(root, level);
   
}
}
  
// This code is contributed by PrinciRaj1992

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation to print the
# nodes of Kth Level without duplicates
from collections import deque
  
# A binary tree node has key, pointer to 
# left child and a pointer to right child
class Node:
  
    def __init__(self, key):
        self.data = key
        self.left = None
        self.right = None
  
# Function to print the nodes
# of Kth Level without duplicates
def nodesAtKthLevel(root: Node, k: int):
      
    # Condition to check if current
    # node is None
    if root is None:
        return
  
    # Create Queue
    que = deque()
  
    # Enqueue the root node
    que.append(root)
  
    # Create a set
    s = set()
  
    # Level to track
    # the current level
    level = 0
    flag = 0
  
    # Iterate the queue till its not empty
    while que:
  
        # Calculate the number of nodes
        # in the current level
        size = len(que)
  
        # Process each node of the current
        # level and enqueue their left
        # and right child to the queue
        while size:
            ptr = que[0]
            que.popleft()
  
            # If the current level matches the
            # required level then add into set
            if level == k:
  
                # Flag initialized to 1
                flag = 1
  
                # Inserting node data in set
                s.add(ptr.data)
  
            else:
  
                # Traverse to the left child
                if ptr.left:
                    que.append(ptr.left)
  
                # Traverse to the right child
                if ptr.right:
                    que.append(ptr.right)
  
            size -= 1
  
        # Increment the variable level
        # by 1 for each level
        level += 1
  
        # Break out from the loop
        # if the Kth Level is reached
        if flag == 1:
            break
  
    for it in s:
        print(it, end = " ")
    print()
  
  
# Driver Code
if __name__ == "__main__":
  
    # Tree Construction
    root = Node(60)
    root.left = Node(20)
    root.right = Node(30)
    root.left.left = Node(80)
    root.left.right = Node(10)
    root.right.left = Node(40)
  
    level = 1
    nodesAtKthLevel(root, level)
  
# This code is contributed by sanjeev2552

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation to print the 
// nodes of Kth Level without duplicates
using System;
using System.Collections.Generic;
  
class GFG{
    
// Structure of Binary Tree node
class node {
    public int data;
    public node left;
    public node right;
};
    
// Function to create new
// Binary Tree node
static node newNode(int data)
{
    node temp = new node();
    temp.data = data;
    temp.left = null;
    temp.right = null;
    return temp;
}
    
// Function to print the nodes
// of Kth Level without duplicates
static void nodesAtKthLevel(node root,
                        int k){
    
    // Condition to check if current 
    // node is None
    if (root == null)
        return;
            
    // Create Queue
    List<node> que = new List<node>();
    
    // Enqueue the root node
    que.Add(root);
    
    // Create a set
    HashSet<int> s = new HashSet<int>();
    
    // Level to track
    // the current level
    int level = 0;
    int flag = 0;
    
    // Iterate the queue till its not empty
    while (que.Count != 0) {
    
        // Calculate the number of nodes
        // in the current level
        int size = que.Count;
    
        // Process each node of the current
        // level and enqueue their left
        // and right child to the queue
        while (size-- > 0) {
            node ptr = que[0];
            que.RemoveAt(0);
    
            // If the current level matches the
            // required level then add into set
            if (level == k) {
    
                // Flag initialized to 1
                flag = 1;
    
                // Inserting node data in set
                s.Add(ptr.data);
            }
            else {
    
                // Traverse to the left child
                if (ptr.left != null)
                    que.Add(ptr.left);
    
                // Traverse to the right child
                if (ptr.right != null)
                    que.Add(ptr.right);
            }
        }
    
        // Increment the variable level
        // by 1 for each level
        level++;
    
        // Break out from the loop 
        // if the Kth Level is reached
        if (flag == 1)
            break;
    }
    foreach (int it in s) {
        Console.Write(it+ " ");
    }
    Console.WriteLine();
}
    
// Driver code
public static void Main(String[] args)
{
    node root = new node();
    
    // Tree Construction
    root = newNode(60);
    root.left = newNode(20);
    root.right = newNode(30);
    root.left.left = newNode(80);
    root.left.right = newNode(10);
    root.right.left = newNode(40);
    int level = 1;
    nodesAtKthLevel(root, level);
    
}
}
  
// This code is contributed by 29AjayKumar

chevron_right


Output:

20 30

Performance Analysis:

  • Time Complexity:As in the above approach in the worst case all the N nodes of the Tree visited, So the Time complexity will be O(N)
  • Space Complexity:As in the worst case at the bottom most level of the Tree it can have the maximum number of the nodes which is 2H-1 where H is the height of the Binary Tree, then Space complexity of the Binary Tree will be O(2H-1)

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

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Article Tags :
Practice Tags :


6


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.