Related Articles

# Prime Numbers present at Kth level of a Binary Tree

• 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 ``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 primes = ``new` `Vector();` `    ``// Function to generate N prime numbers using``    ``// Sieve of Eratosthenes``    ``static` `void` `SieveOfEratosthenes(Vector 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

 ``

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 ```

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up