给定数字的因子树

因子树是理解数字因子的一种直观方法。它显示了所有因素是如何从数字中得出的。这是一个特殊的图表，您可以在其中找到一个数字的因数，然后是这些数字的因数，等等，直到您无法再因数。两端都是原数的质因数。
例子：

Input : v = 48
Output : Root of below tree
   48
   /\
  2  24
     /\
    2  12
       /\
      2  6
         /\
        2  3

因子树是递归创建的。使用二叉树。

1. 我们从一个数字开始，找到可能的最小除数。
2. 然后，我们将父编号除以最小除数。
3. 我们将除数和商都存储为父数的两个子数。
4. 两个孩子都被递归地发送到函数中。
5. 如果未找到小于一半数的除数，则将两个孩子存储为 NULL。

C++

// C++ program to construct Factor Tree for
// a given number
#include
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 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

// 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 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

C#

// 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 q = new Queue();
    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

Javascript

    // 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.

输出：

Level order traversal of constructed factor tree
48 2 24 2 12 2 6 2 3