Open in App
Not now

# Print all Exponential Levels of a Binary Tree

• Difficulty Level : Hard
• Last Updated : 24 Mar, 2023

Given a Binary Tree, the task is to print all the Exponential Levels in the given Binary Tree.

An Exponential Level is a level whose all nodes of that levels equals to xy, & where x is a minimum possible positive constant & y is a variable positive integer.

Examples:

```Input:
20
/    \
9      81
/ \    /  \
3  10  70   243
/     \
81    909
Output:
20
9 81
Explanation:
There are 2 exponential levels:
20: 201 = 20.
9, 81: 32 = 9, 34 = 81.

Input:
8
/     \
4       81
/ \    /   \
5  125  625   5
/   \
81   909
Output:
8
5 125 625 5```

Approach: To solve the problem mentioned above the main idea is to use Level Order Tree Traversal

• Perform level order traversal of the given Binary tree and store each level in a vector.
• Then, in each level, if every node can be expressed in the form of xy, for y â‰¥ 0.
• If any value of the node of this level is not equal to xy, then skip to the next level.
• Print all such levels in which the above condition is true.

Below is the implementation of the above approach:

## C++

 `// C++ program for printing all` `// Exponential levels of binary Tree`   `#include ` `using` `namespace` `std;`   `int` `N = 1e6;`   `// To store all prime numbers` `vector<``int``> prime;`   `void` `SieveOfEratosthenes()` `{` `    ``// Create a boolean array "prime[0..N]" and initialize` `    ``// all entries it as true. A value in prime[i] will` `    ``// finally be false if i is Not a prime, else true.` `    ``bool` `check[N + 1];` `    ``memset``(check, ``true``, ``sizeof``(check));`   `    ``for` `(``int` `p = 2; p * p <= N; p++) {`   `        ``// check if prime[p] is not changed,` `        ``// then it is a prime` `        ``if` `(check[p] == ``true``) {` `            ``prime.push_back(p);`   `            ``// 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 <= N; i += p)` `                ``check[i] = ``false``;` `        ``}` `    ``}` `}`   `// A Tree node` `struct` `Node {` `    ``int` `key;` `    ``struct` `Node *left, *right;` `};`   `// Function to create a new node` `Node* newNode(``int` `key)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->key = key;` `    ``temp->left = temp->right = NULL;` `    ``return` `(temp);` `}`   `// Function To check` `// whether the given node` `// equals to x^y for some y>0` `bool` `is_key(``int` `n, ``int` `x)` `{` `    ``double` `p;`   `    ``// Take logx(n) with base x` `    ``p = ``log10``(n) / ``log10``(x);`   `    ``int` `no = (``int``)(``pow``(x, ``int``(p)));`   `    ``if` `(n == no)` `        ``return` `true``;`   `    ``return` `false``;` `}`   `// Function to find x` `int` `find_x(``int` `n)` `{` `    ``if` `(n == 1)` `        ``return` `1;`   `    ``double` `num, den, p;`   `    ``// Take log10 of n` `    ``num = ``log10``(n);`   `    ``int` `x, no;`   `    ``for` `(``int` `i = 2; i <= n; i++) {` `        ``den = ``log10``(i);`   `        ``// Log(n) with base i` `        ``p = num / den;`   `        ``// Raising i to the power p` `        ``no = (``int``)(``pow``(i, ``int``(p)));`   `        ``if` `(``abs``(no - n) < 1e-6) {` `            ``x = i;` `            ``break``;` `        ``}` `    ``}`   `    ``return` `x;` `}`   `// Function to check whether Level` `// is Exponential or not` `bool` `isLevelExponential(vector<``int``>& L)` `{`   `    ``// retrieve the value of x` `    ``// for that level` `    ``int` `x = find_x(L[0]);`   `    ``for` `(``int` `i = 1; i < L.size(); i++) {`   `        ``// Checking that element is` `        ``// equal x^y for some y` `        ``if` `(!is_key(L[i], x))` `            ``return` `false``;` `    ``}`   `    ``return` `true``;` `}`   `// Function to print an Exponential level` `void` `printExponentialLevels(vector<``int``>& Lev)` `{` `    ``for` `(``auto` `x : Lev) {` `        ``cout << x << ``" "``;` `    ``}`   `    ``cout << endl;` `}`   `// Utility function to get Exponential` `// Level of a given Binary tree` `void` `find_ExponentialLevels(``struct` `Node* node,` `                            ``struct` `Node* queue[],` `                            ``int` `index, ``int` `size)` `{`   `    ``vector<``int``> Lev;`   `    ``while` `(index < size) {` `        ``int` `curr_size = size;`   `        ``while` `(index < curr_size) {` `            ``struct` `Node* temp = queue[index];`   `            ``Lev.push_back(temp->key);`   `            ``// Push left child in a queue` `            ``if` `(temp->left != NULL)` `                ``queue[size++] = temp->left;`   `            ``// Push right child in a queue` `            ``if` `(temp->right != NULL)` `                ``queue[size++] = temp->right;`   `            ``// Increment index` `            ``index++;` `        ``}`   `        ``// check if level is exponential` `        ``if` `(isLevelExponential(Lev)) {`   `            ``printExponentialLevels(Lev);` `        ``}` `        ``Lev.clear();` `    ``}` `}`   `// Function to find total no of nodes` `// In a given binary tree` `int` `findSize(``struct` `Node* node)` `{` `    ``// Base condition` `    ``if` `(node == NULL)` `        ``return` `0;`   `    ``return` `1` `           ``+ findSize(node->left)` `           ``+ findSize(node->right);` `}`   `// Function to find Exponential levels` `// In a given binary tree` `void` `printExponentialLevels(``struct` `Node* node)` `{` `    ``int` `t_size = findSize(node);`   `    ``// Create queue` `    ``struct` `Node* queue[t_size];`   `    ``// Push root node in a queue` `    ``queue[0] = node;`   `    ``find_ExponentialLevels(node, queue, 0, 1);` `}`   `// Driver Code` `int` `main()` `{` `    ``/*            20` `                ``/    \` `               ``9      81` `              ``/ \    /  \` `             ``3   9  81   243` `                    ``/     \` `                   ``81      909 */`   `    ``// Create Binary Tree as shown` `    ``Node* root = newNode(20);` `    ``root->left = newNode(9);` `    ``root->right = newNode(81);`   `    ``root->left->left = newNode(3);` `    ``root->left->right = newNode(9);` `    ``root->right->left = newNode(81);` `    ``root->right->right = newNode(243);`   `    ``root->right->left->left = newNode(81);` `    ``root->right->right->right = newNode(909);`   `    ``// To save all prime numbers` `    ``SieveOfEratosthenes();`   `    ``// Print Exponential Levels` `    ``printExponentialLevels(root);`   `    ``return` `0;` `}`

## Java

 `// Java program for printing all` `// Exponential levels of binary Tree`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `  ``static` `int` `N = (``int``)1e6;`   `  ``static` `List prime = ``new` `ArrayList<>();`   `  ``static` `void` `SieveOfEratosthenes()` `  ``{`   `    ``// Create a boolean array "prime[0..N]" and initialize` `    ``// all entries it as true. A value in prime[i] will` `    ``// finally be false if i is Not a prime, else true.` `    ``boolean` `check[] = ``new` `boolean``[N + ``1``];` `    ``for` `(``int` `p = ``2``; p * p <= N; p++) ` `    ``{`   `      ``// check if prime[p] is not changed,` `      ``// then it is a prime` `      ``if` `(check[p] == ``true``) {` `        ``prime.add(p);`   `        ``// 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 <= N; i += p) {` `          ``check[i] = ``false``;` `        ``}` `      ``}` `    ``}` `  ``}`   `  ``static` `class` `Node {` `    ``int` `key;` `    ``Node left, right;` `  ``}`   `  ``// Function to create a new node` `  ``static` `Node newNode(``int` `key)` `  ``{` `    ``Node temp = ``new` `Node();` `    ``temp.key = key;` `    ``temp.left = temp.right = ``null``;` `    ``return` `temp;` `  ``}`   `  ``// Function To check` `// whether the given node` `// equals to x^y for some y>0` `  ``static` `boolean` `is_key(``int` `n, ``int` `x)` `  ``{` `    ``double` `p;` `    `  `    ``// Take logx(n) with base x` `    ``p = Math.log10(n) / Math.log10(x);`   `    ``int` `no = (``int``)(Math.pow(x, (``int``)p));` `    ``if` `(n == no) {` `      ``return` `true``;` `    ``}` `    ``return` `false``;` `  ``}`   `  ``// Function to find x` `  ``static` `int` `find_x(``int` `n)` `  ``{` `    ``if` `(n == ``1``) {` `      ``return` `1``;` `    ``}` `    ``double` `num, den, p;`   `    ``num = Math.log10(n);`   `    ``int` `x = ``0``;` `    ``int` `no;`   `    ``for` `(``int` `i = ``2``; i <= n; i++) {` `      ``den = Math.log10(i);` `      ``p = num / den;` `      ``no = (``int``)(Math.pow(i, (``int``)p));` `      ``if` `(Math.abs(no - n) < 1e-``6``) {` `        ``x = i;` `        ``break``;` `      ``}` `    ``}` `    ``return` `x;` `  ``}`   `  ``// Function to check whether Level` `// is Exponential or not` `  ``static` `boolean` `isLevelExponential(List L)` `  ``{` `    ``int` `x = find_x(L.get(``0``));` `    ``for` `(``int` `i = ``1``; i < L.size(); i++)` `    ``{` `      ``// Checking that element is` `        ``// equal x^y for some y` `      ``if` `(!is_key(L.get(i), x)) {` `        ``return` `false``;` `      ``}` `    ``}` `    ``return` `true``;` `  ``}`   `  ``static` `void` `printExponentialLevels(List Lev)` `  ``{` `    ``for` `(``int` `i = ``0``; i < Lev.size(); i++) {` `      ``System.out.print(Lev.get(i) + ``" "``);` `    ``}` `    ``System.out.println();` `  ``}`   `  ``// Utility function to get Exponential` `// Level of a given Binary tree` `  ``static` `void` `find_ExponentialLevels(Node node,` `                                     ``List queue,` `                                     ``int` `index, ``int` `size)` `  ``{` `    ``List Lev = ``new` `ArrayList();`   `    ``while` `(index < size) {` `      ``int` `curr_size = size;` `      ``while` `(index < curr_size) {` `        ``Node temp = queue.get(index);` `        ``Lev.add(temp.key);` `        `  `        ``// Push left child in a queue` `        ``if` `(temp.left != ``null``) {` `          ``queue.add(size++, temp.left);` `        ``}` `        `  `        ``// Push right child in a queue` `        ``if` `(temp.right != ``null``) {` `          ``queue.add(size++, temp.right);` `        ``}` `        ``index++;` `      ``}` `      ``if` `(isLevelExponential(Lev)) {` `        ``printExponentialLevels(Lev);` `      ``}` `      ``Lev.clear();` `    ``}` `  ``}`   `  ``static` `int` `findSize(Node node)` `  ``{` `    ``if` `(node == ``null``) {` `      ``return` `0``;` `    ``}` `    ``return` `1` `+ findSize(node.left)` `      ``+ findSize(node.right);` `  ``}`   `  ``static` `void` `printExponentialLevels(Node node)` `  ``{` `    ``int` `t_size = findSize(node);` `    ``List queue = ``new` `ArrayList<>(t_size);` `    ``queue.add(``0``, node);` `    ``find_ExponentialLevels(node, queue, ``0``, ``1``);` `  ``}`   `  ``public` `static` `void` `main(String[] args)` `  ``{`   `    ``Node root = newNode(``20``);` `    ``root.left = newNode(``9``);` `    ``root.right = newNode(``81``);`   `    ``root.left.left = newNode(``3``);` `    ``root.left.right = newNode(``9``);` `    ``root.right.left = newNode(``81``);` `    ``root.right.right = newNode(``243``);`   `    ``root.right.left.left = newNode(``81``);` `    ``root.right.right.right = newNode(``909``);`   `    ``SieveOfEratosthenes();`   `    ``printExponentialLevels(root);` `  ``}` `}`   `// This code is contributed by lokeshmvs21.`

## Python3

 `# Python3 program for printing ` `# all Exponential levels of ` `# binary Tree` `import` `math`   `# A Tree node` `class` `Node:` `    `  `    ``def` `__init__(``self``, key):` `        `  `        ``self``.key ``=` `key` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` `        `  `# Utility function to create` `# a new node` `def` `newNode(key):` `    `  `    ``temp ``=` `Node(key)` `    ``return` `temp`   `N ``=` `1000000` ` `  `# Vector to store all the` `# prime numbers` `prime ``=` `[]` ` `  `# Function to store all the` `# prime numbers in an array` `def` `SieveOfEratosthenes():`   `    ``# Create a boolean array "prime[0..N]"` `    ``# and initialize all the entries in it` `    ``# as true. A value in prime[i]` `    ``# will finally be false if` `    ``# i is Not a prime, else true.` `    ``check ``=` `[``True` `for` `i ``in` `range``(N ``+` `1``)]` `    `  `    ``p ``=` `2` `    `  `    ``while``(p ``*` `p <``=` `N):` ` `  `        ``# If prime[p] is not ` `        ``# changed, then it is ` `        ``# a prime` `        ``if` `(check[p]): ` `            ``prime.append(p);` ` `  `            ``# Update all multiples of p` `            ``# greater than or equal to` `            ``# the square of it` `            ``# numbers which are multiples of p` `            ``# and are less than p^2` `            ``# are already marked.` `            ``for` `i ``in` `range``(p ``*` `p, N ``+` `1``, p):` `                ``check[i] ``=` `False``;` `            `  `        ``p ``+``=` `1`            `# Function To check` `# whether the given node` `# equals to x^y for some y>0` `def` `is_key(n, x):` ` `  `    ``# Take logx(n) with base x` `    ``p ``=` `(math.log10(n) ``/` `         ``math.log10(x));` ` `  `    ``no ``=` `int``(math.``pow``(x, ``int``(p)));` ` `  `    ``if` `(n ``=``=` `no):` `        ``return` `True``;` ` `  `    ``return` `False``;` ` `  `# Function to find x` `def` `find_x(n):`   `    ``if` `(n ``=``=` `1``):` `        ``return` `1``;` ` `  `    ``den ``=` `0` `    ``p ``=` `0` ` `  `    ``# Take log10 of n` `    ``num ``=` `math.log10(n);` ` `  `    ``x ``=` `0` `    ``no ``=` `0``;` `    `  `    ``for` `i ``in` `range``(``2``, n ``+` `1``):    ` `        ``den ``=` `math.log10(i);` ` `  `        ``# Log(n) with base i` `        ``p ``=` `num ``/` `den;` ` `  `        ``# Raising i to the power p` `        ``no ``=` `int``(math.``pow``(i, ``int``(p)));` ` `  `        ``if``(``abs``(no ``-` `n) < ``0.000001``):` `            ``x ``=` `i;` `            ``break``;` `        `  `    ``return` `x;` ` `  `# Function to check whether Level` `# is Exponential or not` `def` `isLevelExponential(L):`   `    ``# retrieve the value of x` `    ``# for that level` `    ``x ``=` `find_x(L[``0``]);` `    `  `    ``for` `i ``in` `range``(``1``, ``len``(L)):` ` `  `        ``# Checking that element is` `        ``# equal x^y for some y` `        ``if` `(``not` `is_key(L[i], x)):` `            ``return` `False``;` ` `  `    ``return` `True``;` ` `  `# Function to print an ` `# Exponential level` `def` `printExponentialLevels(Lev):` `    `  `    ``for` `x ``in` `Lev:` `        ``print``(x, end ``=` `' '``)` `    `  `    ``print``() ` ` `  `# Utility function to get Exponential` `# Level of a given Binary tree` `def` `find_ExponentialLevels(node, queue, ` `                           ``index, size):` ` `  `    ``Lev ``=` `[]` ` `  `    ``while` `(index < size):        ` `        ``curr_size ``=` `size; ` `        ``while` `index < curr_size:            ` `            ``temp ``=` `queue[index];  ` `            ``Lev.append(temp.key);` ` `  `            ``# Push left child in a queue` `            ``if` `(temp.left !``=` `None``):` `                ``queue[size] ``=` `temp.left;` `                ``size ``+``=` `1` ` `  `            ``# Push right child in a queue` `            ``if` `(temp.right !``=` `None``):` `                ``queue[size] ``=` `temp.right;` `                ``size ``+``=` `1` ` `  `            ``# Increment index` `            ``index ``+``=` `1``;        ` ` `  `        ``# check if level is exponential` `        ``if` `(isLevelExponential(Lev)): ` `            ``printExponentialLevels(Lev);` `        `  `        ``Lev.clear();    ` ` `  `# Function to find total no of nodes` `# In a given binary tree` `def` `findSize(node):`   `    ``# Base condition` `    ``if` `(node ``=``=` `None``):` `        ``return` `0``;` ` `  `    ``return` `(``1` `+` `findSize(node.left) ``+` `                ``findSize(node.right));`   ` ``# Function to find Exponential levels` `# In a given binary tree` `def` `printExponentialLevel(node):`   `    ``t_size ``=` `findSize(node);` ` `  `    ``# Create queue` `    ``queue``=``[``0` `for` `i ``in` `range``(t_size)]` ` `  `    ``# Push root node in a queue` `    ``queue[``0``] ``=` `node;` ` `  `    ``find_ExponentialLevels(node, queue, ` `                           ``0``, ``1``);` `    `  `# Driver code    ` `if` `__name__ ``=``=` `"__main__"``:` `    `  `    ``'''            20` `                ``/    \` `               ``9      81` `              ``/ \    /  \` `             ``3   9  81   243` `                    ``/     \` `                   ``81      909 '''` ` `  `    ``# Create Binary Tree as shown` `    ``root ``=` `newNode(``20``);` `    ``root.left ``=` `newNode(``9``);` `    ``root.right ``=` `newNode(``81``);` ` `  `    ``root.left.left ``=` `newNode(``3``);` `    ``root.left.right ``=` `newNode(``9``);` `    ``root.right.left ``=` `newNode(``81``);` `    ``root.right.right ``=` `newNode(``243``);` ` `  `    ``root.right.left.left ``=` `newNode(``81``);` `    ``root.right.right.right ``=` `newNode(``909``);` ` `  `    ``# To save all prime numbers` `    ``SieveOfEratosthenes();` ` `  `    ``# Print Exponential Levels` `    ``printExponentialLevel(root);`   `# This code is contributed by Rutvik_56`

## C#

 `// C# program for printing all` `// Exponential levels of binary Tree`   `using` `System;` `using` `System.Collections.Generic;`   `class` `Node {` `  ``public` `int` `key;` `  ``public` `Node left, right;` `}`   `class` `GFG {`   `  ``static` `int` `N = (``int``)1e6;`   `  ``static` `List<``int``> prime = ``new` `List<``int``>();`   `  ``static` `void` `SieveOfEratosthenes()` `  ``{`   `    ``// Create a boolean array "prime[0..N]" and` `    ``// initialize all entries it as true. A value in` `    ``// prime[i] will finally be false if i is Not a` `    ``// prime, else true.` `    ``bool``[] check = ``new` `bool``[N + 1];` `    ``for` `(``int` `p = 2; p * p <= N; p++) {`   `      ``// check if prime[p] is not changed,` `      ``// then it is a prime` `      ``if` `(check[p] == ``true``) {` `        ``prime.Add(p);`   `        ``// 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 <= N; i += p) {` `          ``check[i] = ``false``;` `        ``}` `      ``}` `    ``}` `  ``}`   `  ``// Function to create a new node` `  ``static` `Node newNode(``int` `key)` `  ``{` `    ``Node temp = ``new` `Node();` `    ``temp.key = key;` `    ``temp.left = temp.right = ``null``;` `    ``return` `temp;` `  ``}`   `  ``// Function To check` `  ``// whether the given node` `  ``// equals to x^y for some y>0` `  ``static` `bool` `is_key(``int` `n, ``int` `x)` `  ``{` `    ``double` `p;`   `    ``// Take logx(n) with base x` `    ``p = Math.Log(n) / Math.Log(x);`   `    ``int` `no = (``int``)(Math.Pow(x, (``int``)p));` `    ``if` `(n == no) {` `      ``return` `true``;` `    ``}` `    ``return` `false``;` `  ``}`   `  ``// Function to find x` `  ``static` `int` `find_x(``int` `n)` `  ``{` `    ``if` `(n == 1) {` `      ``return` `1;` `    ``}` `    ``double` `num, den, p;`   `    ``num = Math.Log10(n);`   `    ``int` `x = 0;` `    ``int` `no;`   `    ``for` `(``int` `i = 2; i <= n; i++) {` `      ``den = Math.Log10(i);` `      ``p = num / den;` `      ``no = (``int``)(Math.Pow(i, (``int``)p));` `      ``if` `(Math.Abs(no - n) < 1e-6) {` `        ``x = i;` `        ``break``;` `      ``}` `    ``}` `    ``return` `x;` `  ``}`   `  ``// Function to check whether Level` `  ``// is Exponential or not` `  ``static` `bool` `isLevelExponential(List<``int``> L)` `  ``{` `    ``int` `x = find_x(L[0]);` `    ``for` `(``int` `i = 1; i < L.Count; i++) {` `      ``// Checking that element is` `      ``// equal x^y for some y` `      ``if` `(!is_key(L[i], x)) {` `        ``return` `false``;` `      ``}` `    ``}` `    ``return` `true``;` `  ``}`   `  ``static` `void` `printExponentialLevels(List<``int``> Lev)` `  ``{` `    ``for` `(``int` `i = 0; i < Lev.Count; i++) {` `      ``Console.Write(Lev[i] + ``" "``);` `    ``}` `    ``Console.Write(``"\n"``);` `  ``}`   `  ``// Utility function to get Exponential` `  ``// Level of a given Binary tree` `  ``static` `void` `find_ExponentialLevels(Node node,` `                                     ``List queue,` `                                     ``int` `index, ``int` `size)` `  ``{` `    ``List<``int``> Lev = ``new` `List<``int``>();`   `    ``while` `(index < size) {` `      ``int` `curr_size = size;` `      ``while` `(index < curr_size) {` `        ``Node temp = queue[index];` `        ``Lev.Add(temp.key);`   `        ``// Push left child in a queue` `        ``if` `(temp.left != ``null``) {` `          ``queue.Insert(size++, temp.left);` `        ``}`   `        ``// Push right child in a queue` `        ``if` `(temp.right != ``null``) {` `          ``queue.Insert(size++, temp.right);` `        ``}` `        ``index++;` `      ``}` `      ``if` `(isLevelExponential(Lev)) {` `        ``printExponentialLevels(Lev);` `      ``}` `      ``Lev.Clear();` `    ``}` `  ``}`   `  ``static` `int` `findSize(Node node)` `  ``{` `    ``if` `(node == ``null``) {` `      ``return` `0;` `    ``}` `    ``return` `1 + findSize(node.left)` `      ``+ findSize(node.right);` `  ``}`   `  ``static` `void` `printExponentialLevels(Node node)` `  ``{` `    ``int` `t_size = findSize(node);` `    ``List queue = ``new` `List(t_size);` `    ``queue.Insert(0, node);` `    ``find_ExponentialLevels(node, queue, 0, 1);` `  ``}`   `  ``public` `static` `void` `Main(``string``[] args)` `  ``{`   `    ``Node root = newNode(20);` `    ``root.left = newNode(9);` `    ``root.right = newNode(81);`   `    ``root.left.left = newNode(3);` `    ``root.left.right = newNode(9);` `    ``root.right.left = newNode(81);` `    ``root.right.right = newNode(243);`   `    ``root.right.left.left = newNode(81);` `    ``root.right.right.right = newNode(909);`   `    ``SieveOfEratosthenes();`   `    ``printExponentialLevels(root);` `  ``}` `}`   `// This code is contributed by phasing17.`

## Javascript

 ``

Output:

```20
9 81
3 9 81 243```

Time Complexity: O(n2*log(n))

Auxiliary Space: O(n)

My Personal Notes arrow_drop_up
Related Articles