Skip to content
Related Articles

Related Articles

Prime Numbers present at Kth level of a Binary Tree

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Medium
  • Last Updated : 18 May, 2021

Given a number K, the task is to print the prime numbers present at that level given all the prime numbers are represented in the form of a binary tree

Examples:  

Input: K = 3
        2
       / \
      3   5
     /\  / \
    7 11 13 17
Output :7, 11, 13, 17
Explanation:
        2
       / \
      3   5
     /\  / \
    7 11 13 17
So primes present at level 3 : 7, 11, 13, 17

Input :K = 2
        2
       / \
      3   5
Output :3 5

Naive Approach: The naive approach is to build a binary tree of prime numbers and then get elements at a particular level k. 
It doesn’t work well for large numbers as it takes too much time.

Efficient approach: Suppose there are n elements and the task is to build a binary tree using those n elements, then they can be built using log2n levels. 
Therefore, given a level k, elements present here is from 2k-1 to 2k-1 if all the prime numbers are present in a 1D array. 

Hence, the following is the algorithm:  

  1. Find the prime numbers upto MAX_SIZE using Sieve of Eratosthenes.
  2. Calculate the left_index and right_index of the level as left_index = 2k-1, right_index = 2k-1.
  3. Output primes from left_index to right_index of prime array.

C++




// CPP program of the approach
#include <bits/stdc++.h>
using namespace std;
 
// initializing the max value
#define MAX_SIZE 1000005
 
// To store all prime numbers
vector<int> primes;
 
// Function to generate N prime numbers using
// Sieve of Eratosthenes
void SieveOfEratosthenes(vector<int>& primes)
{
    // Create a boolean array "IsPrime[0..MAX_SIZE]" and
    // initialize all entries it as true. A value in
    // IsPrime[i] will finally be false if i is
    // Not a IsPrime, else true.
    bool IsPrime[MAX_SIZE];
    memset(IsPrime, true, sizeof(IsPrime));
 
    for (int p = 2; p * p < MAX_SIZE; p++) {
        // If IsPrime[p] is not changed, then it is a prime
        if (IsPrime[p] == true) {
            // Update all multiples of p greater than or
            // equal to the square of it
            // numbers which are multiple of p and are
            // less than p^2 are already been marked.
            for (int i = p * p; i < MAX_SIZE; i += p)
                IsPrime[i] = false;
        }
    }
 
    // Store all prime numbers
    for (int p = 2; p < MAX_SIZE; p++)
        if (IsPrime[p])
            primes.push_back(p);
}
 
void printLevel(int level)
{
 
    cout << "primes at level " << level << ": ";
    int left_index = pow(2, level - 1);
    int right_index = pow(2, level) - 1;
    for (int i = left_index; i <= right_index; i++) {
 
        cout << primes[i - 1] << " ";
    }
    cout << endl;
}
 
// Driver Code
int main()
{
    // Function call
    SieveOfEratosthenes(primes);
 
    printLevel(1);
    printLevel(2);
    printLevel(3);
    printLevel(4);
 
    return 0;
}

Java




// Java program of the approach
import java.util.*;
 
class GFG
{
 
    // initializing the max value
    static final int MAX_SIZE = 1000005;
 
    // To store all prime numbers
    static Vector<Integer> primes = new Vector<Integer>();
 
    // Function to generate N prime numbers using
    // Sieve of Eratosthenes
    static void SieveOfEratosthenes(Vector<Integer> primes)
    {
         
        // Create a boolean array "IsPrime[0..MAX_SIZE]" and
        // initialize all entries it as true. A value in
        // IsPrime[i] will finally be false if i is
        // Not a IsPrime, else true.
        boolean[] IsPrime = new boolean[MAX_SIZE];
        for (int i = 0; i < MAX_SIZE; i++)
            IsPrime[i] = true;
 
        for (int p = 2; p * p < MAX_SIZE; p++)
        {
             
            // If IsPrime[p] is not changed, then it is a prime
            if (IsPrime[p] == true)
            {
                 
                // Update all multiples of p greater than or
                // equal to the square of it
                // numbers which are multiple of p and are
                // less than p^2 are already been marked.
                for (int i = p * p; i < MAX_SIZE; i += p)
                    IsPrime[i] = false;
            }
        }
 
        // Store all prime numbers
        for (int p = 2; p < MAX_SIZE; p++)
            if (IsPrime[p])
                primes.add(p);
    }
 
    static void printLevel(int level)
    {
 
        System.out.print("primes at level " + level + ": ");
        int left_index = (int) Math.pow(2, level - 1);
        int right_index = (int) (Math.pow(2, level) - 1);
        for (int i = left_index; i <= right_index; i++)
        {
 
            System.out.print(primes.get(i - 1) + " ");
        }
        System.out.println();
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Function call
        SieveOfEratosthenes(primes);
 
        printLevel(1);
        printLevel(2);
        printLevel(3);
        printLevel(4);
 
    }
}
 
// This code is contributed by Rajput-Ji

Python3




# Python3 program of the approach
MAX_SIZE = 1000005
primes = []
 
# Function to generate N prime numbers using
# Sieve of Eratosthenes
def SieveOfEratosthenes():
     
    # Create a boolean array "IsPrime[0..MAX_SIZE]" and
    # initialize all entries it as True. A value in
    # IsPrime[i] will finally be false if i is
    # Not a IsPrime, else True.
    IsPrime = [True] * MAX_SIZE
    p = 2
 
    while p * p < MAX_SIZE:
         
        # If IsPrime[p] is not changed, then it is a prime
        if (IsPrime[p] == True):
             
            # Update all multiples of p greater than or
            # equal to the square of it
            # numbers which are multiple of p and are
            # less than p^2 are already been marked.
            for i in range(p * p, MAX_SIZE, p):
                IsPrime[i] = False
        p += 1
 
    # Store all prime numbers
    for p in range(2, MAX_SIZE):
        if (IsPrime[p]):
            primes.append(p)
 
def printLevel(level):
 
    print("primes at level ", level, ":", end=" ")
    left_index = pow(2, level - 1)
    right_index = pow(2, level) - 1
    for i in range(left_index, right_index + 1):
 
        print(primes[i - 1], end=" ")
    print()
 
# Driver Code
 
# Function call
SieveOfEratosthenes()
 
printLevel(1)
printLevel(2)
printLevel(3)
printLevel(4)
 
# This code is contributed by mohit kumar 29

C#




// C# program of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
 
    // initializing the max value
    static readonly int MAX_SIZE = 1000005;
 
    // To store all prime numbers
    static List<int> primes = new List<int>();
 
    // Function to generate N prime numbers using
    // Sieve of Eratosthenes
    static void SieveOfEratosthenes(List<int> primes)
    {
         
        // Create a bool array "IsPrime[0..MAX_SIZE]" and
        // initialize all entries it as true. A value in
        // IsPrime[i] will finally be false if i is
        // Not a IsPrime, else true.
        bool[] IsPrime = new bool[MAX_SIZE];
        for (int i = 0; i < MAX_SIZE; i++)
            IsPrime[i] = true;
 
        for (int p = 2; p * p < MAX_SIZE; p++)
        {
             
            // If IsPrime[p] is not changed, then it is a prime
            if (IsPrime[p] == true)
            {
                 
                // Update all multiples of p greater than or
                // equal to the square of it
                // numbers which are multiple of p and are
                // less than p^2 are already been marked.
                for (int i = p * p; i < MAX_SIZE; i += p)
                    IsPrime[i] = false;
            }
        }
 
        // Store all prime numbers
        for (int p = 2; p < MAX_SIZE; p++)
            if (IsPrime[p])
                primes.Add(p);
    }
 
    static void printLevel(int level)
    {
 
        Console.Write("primes at level " + level + ": ");
        int left_index = (int) Math.Pow(2, level - 1);
        int right_index = (int) (Math.Pow(2, level) - 1);
        for (int i = left_index; i <= right_index; i++)
        {
 
            Console.Write(primes[i - 1] + " ");
        }
        Console.WriteLine();
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        // Function call
        SieveOfEratosthenes(primes);
 
        printLevel(1);
        printLevel(2);
        printLevel(3);
        printLevel(4);
 
    }
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
 
// Javascript program of the approach
 
// Initializing the max value
let MAX_SIZE = 1000005
 
// To store all prime numbers
let primes = new Array();
 
// Function to generate N prime numbers using
// Sieve of Eratosthenes
function SieveOfEratosthenes(primes)
{
     
    // Create a boolean array "IsPrime[0..MAX_SIZE]" and
    // initialize all entries it as true. A value in
    // IsPrime[i] will finally be false if i is
    // Not a IsPrime, else true.
    let IsPrime = new Array(MAX_SIZE).fill(true);
 
    for(let p = 2; p * p < MAX_SIZE; p++)
    {
         
        // If IsPrime[p] is not changed,
        // then it is a prime
        if (IsPrime[p] == true)
        {
             
            // Update all multiples of p greater than or
            // equal to the square of it
            // numbers which are multiple of p and are
            // less than p^2 are already been marked.
            for(let i = p * p; i < MAX_SIZE; i += p)
                IsPrime[i] = false;
        }
    }
 
    // Store all prime numbers
    for(let p = 2; p < MAX_SIZE; p++)
        if (IsPrime[p])
            primes.push(p);
}
 
function printLevel(level)
{
    document.write("primes at level " +
                   level + ": ");
    let left_index = Math.pow(2, level - 1);
    let right_index = Math.pow(2, level) - 1;
     
    for(let i = left_index; i <= right_index; i++)
    {
        document.write(primes[i - 1] + " ");
    }
    document.write("<br>");
}
 
// Driver Code
 
// Function call
SieveOfEratosthenes(primes);
 
printLevel(1);
printLevel(2);
printLevel(3);
printLevel(4);
 
// This code is contributed by _saurabh_jaiswal
 
</script>

Output: 

primes at level 1: 2 
primes at level 2: 3 5 
primes at level 3: 7 11 13 17 
primes at level 4: 19 23 29 31 37 41 43 47 

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!