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

My Personal Notes arrow_drop_up