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.
Implementation:
// C++ program to construct Factor Tree for
// a given number
#include<bits/stdc++.h>
using namespace std;
// Tree node
struct Node
{
struct Node *left, *right;
int key;
};
// Utility function to create a new tree Node
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.
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 Tree
void 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 program
int 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 number
import 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 number
class Node:
def __init__(self, key):
self.left = None
self.right = None
self.key = key
# Utility function to create a new tree Node
def 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 Tree
def 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 value
root = None
root = 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 number
using 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 tree48 2 24 2 12 2 6 2 3
Time Complexity: O(n), where n is the given number.
Space Complexity: O(k), where k is the factor of the number.
