✨ Latest Report: dsa/print all possible n nodes full binary trees

Given an integer n, the task is to find all possible Full Binary Trees with n nodes. The value at the nodes does not contribute to be a criteria for different Full Binary Tree, except for NULL,so take them as 0.

A full binary tree is a binary tree in which every node has exactly 0 or 2 children.

Examples:

Input: N = 7
Output: [[0, 0, 0, null, null, 0, 0, null, null, 0, 0, null, null, null, null],
[0, 0, 0, null, null, 0, 0, 0, 0, null, null, null, null, null, null],
[0, 0, 0, 0, 0, null, null, null, null, 0, 0, null, null, null, null],
[0, 0, 0, 0, 0, null, null, 0, 0, null, null, null, null, null, null],
[0, 0, 0, 0, 0, 0, 0, null, null, null, null, null, null, null, null]]
Explanation: The possible full binary trees are -

Approach:

The simplest way to solve the problem is to use recursion using the concept of memoization and check for each subtree if there is a odd number of nodes or not, because a full binary tree has odd nodes.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

class Node {
  public:
    Node *left;
    Node *right;
    int data;

    Node(int x) {
        data = x;
        left = right = nullptr;
    }
};

// Function to traverse the tree and add all
// the left and right child in the list al
void display(Node *node, vector<int> &arr) {

    // If node = null then terminate the function
    if (node == nullptr) {
        return;
    }

    // If there is left child of Node node
    // then insert it into the list al
    if (node->left != nullptr)
    {
        arr.push_back(node->left->data);
    }
  
    // Otherwise insert null in the list
    else {
        arr.push_back(INT_MIN);
    }

    // Similarly, if there is right child
    // of Node node then insert it into
    // the list al
    if (node->right != nullptr) {
        arr.push_back(node->right->data);
    }
  
    // Otherwise insert null
    else {
        arr.push_back(INT_MIN);
    }

    // Recursively call the function
    // for left child and right child
    // of the Node node
    display(node->left, arr);
    display(node->right, arr);
}

vector<Node *> allPossibleFBT(int n, map<int, vector<Node *>> &mp) {
  
    // Check whether tree exists for given n
  	// value or not.
    if (mp.find(n) == mp.end()) {
      
        // Create a list containing nodes
        vector<Node *> list;

        // If N=1, Only one tree can exist
        // i.e. tree with root.
        if (n == 1) {
          
            list.push_back(new Node(0));
        }

        // Check if N is odd because binary full
        // tree has N nodes
        else if (n % 2 == 1) {
          
            // Iterate through all the nodes that
            // can be in the left subtree
            for (int x = 0; x < n; x++) {

                // Remaining Nodes belongs to the
                // right subtree of the node
                int y = n - 1 - x;

                // Iterate through all left Full Binary Tree
                //  by recursively calling the function
                vector<Node *> xallPossibleFBT = 
                  				allPossibleFBT(x, mp);
                vector<Node *> yallPossibleFBT =
                  				allPossibleFBT(y, mp);
                for (int Left = 0; Left < xallPossibleFBT.size(); Left++) {

                    // Iterate through all the right Full
                    // Binary tree by recursively calling
                    // the function
                    for (int Right = 0; Right < yallPossibleFBT.size();
                         									Right++) {

                        // Create a new node
                        Node *node = new Node(0);

                        // Modify the left node
                        node->left = xallPossibleFBT[Left];

                        // Modify the right node
                        node->right = yallPossibleFBT[Right];

                        // Add the node in the list
                        list.push_back(node);
                    }
                }
            }
        }

        mp.insert({n, list});
    }
    return mp[n];
}

int main() {
  
    int n = 7;
    map<int, vector<Node *>> mp;
    vector<Node *> list = allPossibleFBT(n, mp);

    for (int root = 0; root < list.size(); root++) {
        vector<int> arr;
        arr.push_back((list[root])->data);
        display(list[root], arr);

        cout << "[";
        for (int i = 0; i < arr.size(); i++) {
            if (i != arr.size() - 1) {
                if (arr[i] == INT_MIN)
                    cout << "null, ";
                else
                    cout << arr[i] << ", ";
            }
            else {
                if (arr[i] == INT_MIN)
                    cout << "null]";
                else
                    cout << arr[i] << "]";
            }
        }
        cout << endl;
    }

    return 0;
}

Java

// Java program for finding all possible
// full binary trees
import java.util.*;

class Node {
    Node left;
    Node right;
    int data;

    Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {
  
    // Function to traverse the tree and add all
    // the left and right child in the list al
    static void display(Node node, List<Integer> al) {
      
        // If node = null then terminate the function
        if (node == null) {
            return;
        }

        // If there is left child of Node node
        // then insert it into the list al
        if (node.left != null) {
            al.add(node.left.data);
        }
      
        // Otherwise insert null in the list
        else {
            al.add(Integer.MIN_VALUE);
        }

        // Similarly, if there is right child
        // of Node node then insert it into
        // the list al
        if (node.right != null) {
            al.add(node.right.data);
        }
      
        // Otherwise insert null
        else {
            al.add(Integer.MIN_VALUE);
        }

        // Recursively call the function
        // for left child and right child
        // of the Node node
        display(node.left, al);
        display(node.right, al);
    }

    static List<Node>
    allPossibleFBT(int n, Map<Integer, List<Node> > mp) {
      
        // Check whether tree exists for given n value or
        // not.
        if (!mp.containsKey(n)) {
            List<Node> list = new ArrayList<>();

            // If N=1, Only one tree can exist
            // i.e. tree with root.
            if (n == 1) {
                list.add(new Node(0));
            }
          
            // Check if N is odd because binary full
            // tree has N nodes
            else if (n % 2 == 1) {

                // Iterate through all the nodes that
                // can be in the left subtree
                for (int x = 0; x < n; x++) {

                    // Remaining Nodes belongs to the
                    // right subtree of the node
                    int y = n - 1 - x;

                    // Iterate through all left Full Binary
                    // Tree by recursively calling the
                    // function
                    List<Node> xallPossibleFBT
                        = allPossibleFBT(x, mp);
                    List<Node> yallPossibleFBT
                        = allPossibleFBT(y, mp);
                    for (Node leftNode : xallPossibleFBT) {

                        // Iterate through all the right
                        // Full Binary tree by recursively
                        // calling the function
                        for (Node rightNode :
                             yallPossibleFBT) {

                            // Create a new node
                            Node node = new Node(0);

                            // Modify the left node
                            node.left = leftNode;

                            // Modify the right node
                            node.right = rightNode;

                            // Add the node in the list
                            list.add(node);
                        }
                    }
                }
            }
            mp.put(n, list);
        }
        return mp.get(n);
    }

    public static void main(String[] args) {
      
        int n = 7;
        Map<Integer, List<Node> > mp = new HashMap<>();
        List<Node> list = allPossibleFBT(n, mp);

        for (Node root : list) {
            List<Integer> al = new ArrayList<>();
            al.add(root.data);
            display(root, al);

            System.out.print("[");
            for (int i = 0; i < al.size(); i++) {
                if (i != al.size() - 1) {
                    System.out.print(
                        (al.get(i) == Integer.MIN_VALUE
                             ? "null"
                             : al.get(i))
                        + ", ");
                }
                else {
                    System.out.print(
                        (al.get(i) == Integer.MIN_VALUE
                             ? "null"
                             : al.get(i))
                        + "]");
                }
            }
            System.out.println();
        }
    }
}

Python

# Python program for finding all possible
# full binary trees

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

def display(node, al):
  
    # If node = None then terminate
    # the function
    if node is None:
        return
    
    # If there is left child of Node node
    # then insert it into the list al
    if node.left is not None:
        al.append(node.left.data)
    else:
        al.append(None)
    
    # Similarly, if there is right child
    # of Node node then insert it into
    # the list al
    if node.right is not None:
        al.append(node.right.data)
    else:
        al.append(None)
    
    # Recursively call the function
    # for left child and right child
    # of the Node node
    display(node.left, al)
    display(node.right, al)

def allPossibleFBT(n, mp):
  
    # Check whether tree exists for 
    # given n value or not.
    if n not in mp:
        list_ = []
        
        # If N=1, Only one tree can exist
        # i.e. tree with root.
        if n == 1:
            list_.append(Node(0))
        
        # Check if N is odd because binary full
        # tree has N nodes
        elif n % 2 == 1:
          
          	# Iterate through all the nodes that
            # can be in the left subtree
            for x in range(n):
              
              	# Remaining Nodes belongs to the
               	# right subtree of the node
                y = n - 1 - x
                
                # Iterate through all left Full Binary Tree
              	# by recursively calling the function
                xallPossibleFBT = allPossibleFBT(x, mp)
                yallPossibleFBT = allPossibleFBT(y, mp)
                for left in xallPossibleFBT:
                  
                  	# Iterate through all the right Full
                    # Binary tree by recursively calling
                    # the function
                    for right in yallPossibleFBT:
                      
                      	#Create new node
                        node = Node(0)
                        
                        # Modify left subtree
                        node.left = left
                        
                        # Modify right subtree
                        node.right = right
                        
                        # Append node to list
                        list_.append(node)
        
        # Memorize the result
        mp[n] = list_
    return mp[n]

if __name__ == "__main__":
    n = 7
    mp = {}
    list_ = allPossibleFBT(n, mp)

    for root in list_:
        al = [root.data]
        display(root, al)
        print("[", end="")
        print(", ".join("null" if i is None else str(i) for i in al), end="")
        print("]")

// C# program for finding all possible 
// full binary trees
using System;
using System.Collections.Generic;

class Node {
    public Node left;
    public Node right;
    public int data;

    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {

    // Function to traverse the tree and add all
    // the left and right child in the list al
    static void Display(Node node, List<int> arr) {
      
        // If node is null, terminate the function
        if (node == null)
            return;

        // If there is a left child of Node
        // node, insert it into the list al
        if (node.left != null) {
            arr.Add(node.left.data);
        }
        else {
          
            // Otherwise insert int.MinValue
            // in the list to indicate null
            arr.Add(int.MinValue);
        }

        // Similarly, if there is a right child of
        // Node node, insert it into the list al
        if (node.right != null) {
            arr.Add(node.right.data);
        }
        else {
          
            // Otherwise insert int.MinValue
            arr.Add(int.MinValue);
        }

        // Recursively call the function for left and
        // right children of the Node node
        Display(node.left, arr);
        Display(node.right, arr);
    }

    // Function to generate all possible full
    // binary trees with n nodes
    static List<Node>
    AllPossibleFBT(int n, Dictionary<int, List<Node> > mp) {

        // Check whether a tree exists for the
        // given n value in the dictionary
        if (!mp.ContainsKey(n)) {
            List<Node> list = new List<Node>();

            // If N=1, only one tree can exist
            // with the root node only
            if (n == 1) {
                list.Add(new Node(0));
            }

            // Check if N is odd, as full binary
            // trees only have odd numbers of nodes
            else if (n % 2 == 1) {

                // Iterate through all nodes that
                // can be in the left subtree
                for (int x = 0; x < n; x++) {

                    // Remaining nodes belong to the right
                    // subtree
                    int y = n - 1 - x;

                    // Recursively generate all
                    // possible left and right subtrees
                    List<Node> xallPossibleFBT
                        = AllPossibleFBT(x, mp);
                    List<Node> yallPossibleFBT
                        = AllPossibleFBT(y, mp);

                    foreach(Node left in xallPossibleFBT) {

                        // Combine left and right
                        // subtrees with a new root node
                        foreach(
                            Node right in yallPossibleFBT) {
                            Node node = new Node(0);
                            node.left = left;
                            node.right = right;
                            list.Add(node);
                        }
                    }
                }
            }

            mp[n] = list;
        }
        return mp[n];
    }
   static void Main(string[] args) {
        int n = 7;
        Dictionary<int, List<Node> > mp
            = new Dictionary<int, List<Node> >();
        List<Node> list = AllPossibleFBT(n, mp);

        foreach(Node root in list) {
            List<int> arr = new List<int>{ root.data };
            Display(root, arr);

            Console.Write("[");
            for (int i = 0; i < arr.Count; i++) {
        
                Console.Write(
                    (arr[i] == int.MinValue
                         ? "null"
                         : arr[i].ToString())
                    + (i != arr.Count - 1 ? ", " : "]"));
            }
            Console.WriteLine();
        }
    }
}

JavaScript

// JavaScript program for finding all possible full binary
// trees

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Function to traverse the tree and add all the
// left and right child in the array al
function display(node, al) {

    // If node is null, terminate the function
    if (node === null)
        return;

    // If there is a left child of Node node,
    // insert it into the array al
    if (node.left !== null) {
        al.push(node.left.data);
    }
    else {
    
        // Otherwise insert null in the array
        // to represent absence of a left child
        al.push(null);
    }

    // Similarly, if there is a right child of
    // Node node, insert it into the array al
    if (node.right !== null) {
        al.push(node.right.data);
    }
    else {
    
        // Otherwise insert null
        al.push(null);
    }

    // Recursively call the function for the
    // left and right children of the Node node
    display(node.left, al);
    display(node.right, al);
}

// Function to generate all possible full binary trees with
// n nodes
function allPossibleFBT(n, mp) {

    // Check whether a tree exists for the
    // given n value in the map
    if (!mp.has(n)) {
        let list = [];

        // If N=1, only one tree can exist, 
        // with just the root node
        if (n === 1) {
            list.push(new Node(0));
        }
        
        // Check if N is odd, as full binary
        // trees only have odd numbers of nodes
        else if (n % 2 === 1) {
        
            // Iterate through all nodes that
            // can be in the left subtree
            for (let x = 0; x < n; x++) {
            
                // Remaining nodes belong to the right
                // subtree
                let y = n - 1 - x;

                // Recursively generate all
                // possible left and right subtrees
                let xallPossibleFBT = allPossibleFBT(x, mp);
                let yallPossibleFBT = allPossibleFBT(y, mp);

                for (let left of xallPossibleFBT) {
                
                    // Combine left and right
                    // subtrees with a new root node
                    for (let right of yallPossibleFBT) {
                        let node = new Node(0);
                        node.left = left;
                        node.right = right;
                        list.push(node);
                    }
                }
            }
        }
        mp.set(n, list);
    }
    return mp.get(n);
}

let n = 7;
let mp = new Map();
let list = allPossibleFBT(n, mp);

for (let root of list) {
    let al = [ root.data ];
    display(root, al);

    console.log("["
                + al.map(val => val === null ? "null" : val)
                      .join(", ")
                + "]");
}

Output

[0, 0, 0, null, null, 0, 0, null, null, 0, 0, null, null, null, null]
[0, 0, 0, null, null, 0, 0, 0, 0, null, null, null, null, null, null]
[0, 0, 0, 0, 0, null, null, null, null, 0, 0, null, null, null, null]
[0, 0, 0, 0, 0, null, null, 0, 0, null, null, null, null, null, null]
[0, 0, 0, 0, 0, 0, 0, null, null, null, null, null, null, null, null]

Time Complexity: O(2^n), where n is number of nodes given.
Auxiliary Space: O(2^n)

Print all possible N-nodes Full Binary Trees

Explore