Print all Exponential Levels of a Binary Tree

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 x^y, & 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 x^y, for y ≥ 0.
• If any value of the node of this level is not equal to x^y, 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 <bits/stdc++.h>
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<Integer> 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<Integer> 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<Integer> 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<Node> queue,
                                     int index, int size)
  {
    List<Integer> Lev = new ArrayList<Integer>();

    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<Node> 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<Node> 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<Node> queue = new List<Node>(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

<script>

    // JavaScript program for printing all
    // Exponential levels of binary Tree

    let Lev = []

    // A Tree Node
    class Node {
        constructor(key) {
           this.left = null;
           this.right = null;
           this.key = key;
        }
    };

    // Function to create a new node
    function newNode(key)
    {
        let temp = new Node(key);
        return temp;
    }

    let N = 1e6;

    // To store all prime numbers
    let prime = [];

    function 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.
        let check = new Array(N + 1);
        check.fill(true);

        for (let p = 2; p * p <= N; p++) {

            // check if prime[p] is not changed,
            // then it is a prime
            if (check[p] == true) {
                prime.push(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 (let i = p * p; i <= N; i += p)
                    check[i] = false;
            }
        }
    }

    // Function To check
    // whether the given node
    // equals to x^y for some y>0
    function is_key(n, x)
    {
        let p;

        // Take logx(n) with base x
        p = Math.log10(n) / Math.log10(x);

        let no = parseInt(Math.pow(x, parseInt(p, 10)), 10);

        if (n == no)
            return true;

        return false;
    }

    // Function to find x
    function find_x(n)
    {
        if (n == 1)
            return 1;

        let num, den, p;

        // Take log10 of n
        num = Math.log10(n);

        let x, no;

        for (let i = 2; i <= n; i++) {
            den = Math.log10(i);

            // Log(n) with base i
            p = num / den;

            // Raising i to the power p
            no = parseInt(Math.pow(i, parseInt(p, 10)), 10);

            if (Math.abs(no - n) < 1e-6) {
                x = i;
                break;
            }
        }

        return x;
    }

    // Function to check whether Level
    // is Exponential or not
    function isLevelExponential(L)
    {

        // retrieve the value of x
        // for that level
        let x = find_x(L[0]);

        for (let i = 1; i < L.length; 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
    function printExponentialLevels()
    {
        for (let x = 0; x < Lev.length; x++) {
            document.write(Lev[x] + " ");
        }

        document.write("</br>");
    }

    // Utility function to get Exponential
    // Level of a given Binary tree
    function find_ExponentialLevels(node, queue, index, size)
    {
        while (index < size) {
            let curr_size = size;

            while (index < curr_size) {
                let temp = queue[index];

                Lev.push(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 = [];
        }
    }

    // Function to find total no of nodes
    // In a given binary tree
    function findSize(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
    function printexponentialLevels(node)
    {
        let t_size = findSize(node);

        // Create queue
        let queue = new Array(t_size);
        queue.fill(0);

        // Push root node in a queue
        queue[0] = node;

        find_ExponentialLevels(node, queue, 0, 1);
    }

    /*            20
                /    \
               9      81
              / \    /  \
             3   9  81   243
                    /     \
                   81      909 */

    // Create Binary Tree as shown
    let 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);

</script>

Output:

20 
9 81 
3 9 81 243

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

Auxiliary Space: O(n)