Open In App

Print all Exponential Levels of a Binary Tree

Improve
Improve
Like Article
Like
Save
Share
Report

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 <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(n2*log(n))

Auxiliary Space: O(n)



Last Updated : 24 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads