Factor Tree of a given Number - GeeksforGeeks

12 Apr, 2022
Factor Tree is an intuitive method to understand the factors of a number. It shows how all the factors are been derived from the number. It is a special diagram where you find the factors of a number, then the factors of those numbers, etc until you can’t factor anymore. The ends are all the prime factors of the original number.Example:  
Input : v = 48
Output : Root of below tree
   48
   /\
  2  24
     /\
    2  12
       /\
      2  6
         /\
        2  3
 
The factor tree is created recursively. A binary tree is used.  
We start with a number and find the minimum divisor possible.Then, we divide the parent number by the minimum divisor.We store both the divisor and quotient as two children of the parent number.Both the children are sent into function recursively.If a divisor less than half the number is not found, two children are stored as NULL.
We start with a number and find the minimum divisor possible.
Then, we divide the parent number by the minimum divisor.
We store both the divisor and quotient as two children of the parent number.
Both the children are sent into function recursively.
If a divisor less than half the number is not found, two children are stored as NULL.
 
C++
Java
Python3
C#
Javascript
// C++ program to construct Factor Tree for// a given number#include<bits/stdc++.h>using namespace std; // Tree nodestruct Node{    struct Node *left, *right;    int key;}; // Utility function to create a new tree NodeNode* newNode(int key){    Node* temp = new Node;    temp->key = key;    temp->left = temp->right = NULL;    return temp;} // Constructs factor tree for given value and stores// root of tree at given reference.void createFactorTree(struct Node **node_ref, int v){    (*node_ref) = newNode(v);     // the number is factorized    for (int i = 2 ; i < v/2 ; i++)    {        if (v % i != 0)          continue;         // If we found a factor, we construct left        // and right subtrees and return. Since we        // traverse factors starting from smaller        // to greater, left child will always have        // smaller factor        createFactorTree(&((*node_ref)->left), i);        createFactorTree(&((*node_ref)->right), v/i);        return;    }} // Iterative method to find the height of Binary Treevoid printLevelOrder(Node *root){    // Base Case    if (root == NULL)  return;     queue<Node *> q;    q.push(root);     while (q.empty() == false)    {        // Print front of queue and remove        // it from queue        Node *node = q.front();        cout << node->key << " ";        q.pop();        if (node->left != NULL)            q.push(node->left);        if (node->right != NULL)            q.push(node->right);    }} // driver programint main(){    int val = 48;// sample value    struct Node *root = NULL;    createFactorTree(&root, val);    cout << "Level order traversal of "            "constructed factor tree";    printLevelOrder(root);    return 0;}
// Java program to construct Factor Tree for// a given numberimport java.util.*;class GFG{   // Tree node  static class Node  {    Node left, right;    int key;  };  static Node root;   // Utility function to create a new tree Node  static Node newNode(int key)  {    Node temp = new Node();    temp.key = key;    temp.left = temp.right = null;    return temp;  }   // Constructs factor tree for given value and stores  // root of tree at given reference.  static Node createFactorTree(Node node_ref, int v)  {    (node_ref) = newNode(v);     // the number is factorized    for (int i = 2 ; i < v/2 ; i++)    {      if (v % i != 0)        continue;       // If we found a factor, we construct left      // and right subtrees and return. Since we      // traverse factors starting from smaller      // to greater, left child will always have      // smaller factor      node_ref.left = createFactorTree(((node_ref).left), i);      node_ref.right =  createFactorTree(((node_ref).right), v/i);      return node_ref;    }    return node_ref;  }   // Iterative method to find the height of Binary Tree  static void printLevelOrder(Node root)  {     // Base Case    if (root == null)  return;    Queue<Node > q = new LinkedList<>();    q.add(root);    while (q.isEmpty() == false)    {       // Print front of queue and remove      // it from queue      Node node = q.peek();      System.out.print(node.key + " ");      q.remove();      if (node.left != null)        q.add(node.left);      if (node.right != null)        q.add(node.right);    }  }   // Driver program  public static void main(String[] args)  {    int val = 48;// sample value    root = null;    root = createFactorTree(root, val);    System.out.println("Level order traversal of "+                       "constructed factor tree");    printLevelOrder(root);  }} // This code is contributed by Rajput-Ji
# Python program to construct Factor Tree for# a given numberclass Node:    def __init__(self, key):        self.left = None        self.right = None        self.key = key # Utility function to create a new tree Nodedef newNode(key):    temp = Node(key)    return temp # Constructs factor tree for given value and stores# root of tree at given reference.def createFactorTree(node_ref, v):    node_ref = newNode(v)     # the number is factorized    for i in range(2, int(v/2)):         if (v % i != 0):            continue         # If we found a factor, we construct left        # and right subtrees and return. Since we        # traverse factors starting from smaller        # to greater, left child will always have        # smaller factor        node_ref.left = createFactorTree(((node_ref).left), i)        node_ref.right = createFactorTree(((node_ref).right), int(v/i))        return node_ref     return node_ref # Iterative method to find the height of Binary Treedef printLevelOrder(root):     # Base Case    if (root == None):        return    q = [];    q.append(root);    while (len(q) > 0):         # Print front of queue and remove        # it from queue        node = q[0]        print(node.key, end = " ")        q = q[1:]        if (node.left != None):                q.append(node.left)        if (node.right != None):                q.append(node.right) val = 48# sample valueroot = Noneroot = createFactorTree(root, val)print("Level order traversal of constructed factor tree")printLevelOrder(root) # This code is contributed by shinjanpatra
// C# program to construct Factor Tree for// a given numberusing System;using System.Collections.Generic; public class GFG{   // Tree node  public    class Node    {      public        Node left, right;      public        int key;    };  static Node root;   // Utility function to create a new tree Node  static Node newNode(int key)  {    Node temp = new Node();    temp.key = key;    temp.left = temp.right = null;    return temp;  }   // Constructs factor tree for given value and stores  // root of tree at given reference.  static Node createFactorTree(Node node_ref, int v)  {    (node_ref) = newNode(v);     // the number is factorized    for (int i = 2 ; i < v/2 ; i++)    {      if (v % i != 0)        continue;       // If we found a factor, we construct left      // and right subtrees and return. Since we      // traverse factors starting from smaller      // to greater, left child will always have      // smaller factor      node_ref.left = createFactorTree(((node_ref).left), i);      node_ref.right =  createFactorTree(((node_ref).right), v/i);      return node_ref;    }    return node_ref;  }   // Iterative method to find the height of Binary Tree  static void printLevelOrder(Node root)  {     // Base Case    if (root == null)  return;    Queue<Node > q = new Queue<Node>();    q.Enqueue(root);    while (q.Count != 0)    {       // Print front of queue and remove      // it from queue      Node node = q.Peek();      Console.Write(node.key + " ");      q.Dequeue();      if (node.left != null)        q.Enqueue(node.left);      if (node.right != null)        q.Enqueue(node.right);    }  }   // Driver program  public static void Main(String[] args)  {    int val = 48;// sample value    root = null;    root = createFactorTree(root, val);    Console.WriteLine("Level order traversal of "+                      "constructed factor tree");    printLevelOrder(root);  }} // This code is contributed by gauravrajput1
<script>    // Javascript program to construct Factor Tree for    // a given number         class Node    {        constructor(key) {           this.left = null;           this.right = null;           this.key = key;        }    }         let root;      // Utility function to create a new tree Node    function newNode(key)    {      let temp = new Node(key);      return temp;    }     // Constructs factor tree for given value and stores    // root of tree at given reference.    function createFactorTree(node_ref, v)    {      (node_ref) = newNode(v);       // the number is factorized      for (let i = 2 ; i < parseInt(v/2, 10) ; i++)      {        if (v % i != 0)          continue;         // If we found a factor, we construct left        // and right subtrees and return. Since we        // traverse factors starting from smaller        // to greater, left child will always have        // smaller factor        node_ref.left = createFactorTree(((node_ref).left), i);        node_ref.right =  createFactorTree(((node_ref).right), parseInt(v/i, 10));        return node_ref;      }      return node_ref;    }     // Iterative method to find the height of Binary Tree    function printLevelOrder(root)    {       // Base Case      if (root == null)  return;      let q = [];      q.push(root);      while (q.length > 0)      {         // Print front of queue and remove        // it from queue        let node = q[0];        document.write(node.key + " ");        q.shift();        if (node.left != null)          q.push(node.left);        if (node.right != null)          q.push(node.right);      }    }         let val = 48;// sample value    root = null;    root = createFactorTree(root, val);    document.write("Level order traversal of "+                       "constructed factor tree" + "</br>");    printLevelOrder(root);       // This code is contributed by suresh07.</script>
Output:  
Level order traversal of constructed factor tree
48 2 24 2 12 2 6 2 3 
This article is contributed by Suprotik Dey. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
shubham_singh
Rajput-Ji
GauravRajput1
suresh07
simmytarika5
surinderdawra388
shinjanpatra
prime-factor
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Binary Tree | Set 3 (Types of Binary Tree)
Inorder Tree Traversal without Recursion
Binary Tree | Set 2 (Properties)
Decision Tree
A program to check if a binary tree is BST or not
Construct Tree from given Inorder and Preorder traversals
Introduction to Tree Data Structure
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
Expression Tree
Deletion in a Binary Tree