All Possible Full Binary Trees - Practice Coding Problems

All Possible Full Binary Trees - Problem

All Possible Full Binary Trees

Given an integer n, generate and return a list of all possible full binary trees with exactly n nodes. Each node in every tree should have a value of 0.

A full binary tree is a binary tree where every node has either exactly 0 children (leaf node) or exactly 2 children (internal node). No node can have just 1 child.

Key Points:
• All nodes must have Node.val = 0
• Each tree must have exactly n nodes
• Every node has 0 or 2 children (never 1)
• Return trees can be in any order

This problem combines tree construction, recursion, and dynamic programming to efficiently generate all valid tree structures.

Input & Output

example_1.py — Small tree

$ Input: n = 7

› Output: [[0,0,0,null,null,0,0,null,null,0,0],[0,0,0,null,null,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,null,null,null,null,0,0],[0,0,0,0,0,null,null,0,0]]

💡 Note: For n=7, there are 5 different full binary trees possible. Each tree has exactly 7 nodes, and every internal node has exactly 2 children.

example_2.py — Single node

$ Input: n = 1

› Output: [[0]]

💡 Note: With only 1 node, there's exactly one possible tree: a single node with value 0.

example_3.py — Even number

$ Input: n = 4

› Output: []

💡 Note: No full binary tree can have an even number of nodes. This is because each internal node adds exactly 2 children, so the total count is always 1 + 2k = odd.

Visualization

Tap to expand

Understanding the Visualization

Check if Possible

Full binary trees can only have odd number of nodes (1, 3, 5, 7, ...)

Base Case

For n=1, return single node tree with value 0

Split Strategy

For n nodes, try all ways to split into i left nodes and (n-1-i) right nodes

Recursive Building

Get all possible left subtrees and right subtrees recursively

Combination

Combine each left subtree with each right subtree to form complete trees

Memoization

Store results to avoid recalculating same subproblems

Key Takeaway

🎯 Key Insight: Full binary trees follow a recursive pattern where each tree can be built by choosing a root and recursively constructing all possible left and right subtrees, with memoization preventing redundant work.

Time & Space Complexity

Time Complexity

⏱️

O(4^n / √n)

This is the nth Catalan number complexity - each unique subproblem is solved only once

✓ Linear Growth

Space Complexity

O(4^n / √n)

Space for memoization table plus space to store all generated trees

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 20
n is a positive integer
All nodes in returned trees must have val = 0
Each tree must be a full binary tree (0 or 2 children per node)

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses recursive tree construction with memoization. Key insights: full binary trees can only have odd number of nodes, and we can build larger trees by recursively combining smaller valid subtrees. Memoization prevents recalculating the same subproblems, achieving O(4^n/√n) complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive with Memoization (Optimal)	O(4^n / √n)	O(4^n / √n)	Use recursion with memoization to avoid recalculating same subproblems

Recursive with Memoization (Optimal) — Algorithm Steps

Create memoization dictionary to store results
Base case: if n = 1, return single node tree
If n is even, return empty list (impossible)
Check memo for previously calculated result
For each valid split i, get memoized left and right subtrees
Combine all left-right pairs and store result in memo
Return memoized result

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Memo

Before computing, check if result already exists

Compute Once

Calculate result only if not in memo

Store Result

Save computed result for future use

Reuse

Return memoized result for repeated queries

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_N 21

typedef struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

typedef struct {
    TreeNode** trees;
    int size;
} MemoEntry;

MemoEntry memo[MAX_N];
int memoInitialized = 0;

TreeNode* createNode(int val) {
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

TreeNode** allPossibleFBT(int n, int* returnSize) {
    if (!memoInitialized) {
        memset(memo, 0, sizeof(memo));
        memoInitialized = 1;
    }
    
    // Check memo first
    if (memo[n].trees != NULL) {
        *returnSize = memo[n].size;
        return memo[n].trees;
    }
    
    // Base case: single node
    if (n == 1) {
        TreeNode** result = (TreeNode**)malloc(sizeof(TreeNode*));
        result[0] = createNode(0);
        memo[n].trees = result;
        memo[n].size = 1;
        *returnSize = 1;
        return result;
    }
    
    // Full binary trees must have odd number of nodes
    if (n % 2 == 0) {
        memo[n].trees = NULL;
        memo[n].size = 0;
        *returnSize = 0;
        return NULL;
    }
    
    TreeNode** result = (TreeNode**)malloc(1000 * sizeof(TreeNode*));
    int count = 0;
    
    // Try all possible splits
    for (int i = 1; i < n; i += 2) {
        int leftSize, rightSize;
        TreeNode** leftTrees = allPossibleFBT(i, &leftSize);
        TreeNode** rightTrees = allPossibleFBT(n - 1 - i, &rightSize);
        
        // Combine each left with each right
        for (int l = 0; l < leftSize; l++) {
            for (int r = 0; r < rightSize; r++) {
                TreeNode* root = createNode(0);
                root->left = leftTrees[l];
                root->right = rightTrees[r];
                result[count++] = root;
            }
        }
    }
    
    memo[n].trees = result;
    memo[n].size = count;
    *returnSize = count;
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    int size;
    TreeNode** trees = allPossibleFBT(n, &size);
    printf("%d\n", size);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^n / √n)

This is the nth Catalan number complexity - each unique subproblem is solved only once

✓ Linear Growth

Space Complexity

O(4^n / √n)

Space for memoization table plus space to store all generated trees

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 20
n is a positive integer
All nodes in returned trees must have val = 0
Each tree must be a full binary tree (0 or 2 children per node)

87.6K Views

Medium Frequency

~25 min Avg. Time

2.3K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler