All Possible Full Binary Trees

All Possible Full Binary Trees - Problem

Given an integer n, return a list of all possible full binary trees with n nodes.

Each node of each tree in the answer must have Node.val == 0. Each element of the answer is the root node of one possible tree. You may return the final list of trees in any order.

A full binary tree is a binary tree where each node has exactly 0 or 2 children.

Input & Output

Example 1 — Small Tree

$ Input: n = 5

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

💡 Note: With 5 nodes, we can create 2 different full binary trees: one with root having left subtree of 1 node and right subtree of 3 nodes, and another with left subtree of 3 nodes and right subtree of 1 node.

Example 2 — Single Node

$ Input: n = 1

› Output: [[0]]

💡 Note: Only one possible tree: a single root node with value 0.

Example 3 — Impossible Case

$ Input: n = 4

› Output: []

💡 Note: Cannot create a full binary tree with 4 nodes since full binary trees require an odd number of nodes (1 root + even number of children).

Constraints

1 ≤ n ≤ 20
n is guaranteed to be odd for non-empty results

Visualization

Tap to expand

Asked in

f Facebook 15 a Amazon 12 G Google 8 M Microsoft 6

The key insight is that full binary trees need odd number of nodes and can be built by recursively generating left and right subtrees. The memoized approach caches results to avoid redundant calculations. Time: O(4ⁿ/n³/²), Space: O(4ⁿ/n³/²).

Common Approaches

✓ Memoized Recursion

⏱️ Time: O(4ⁿ/n³/²) Space: O(4ⁿ/n³/²)

Same recursive approach but store results for each n value to avoid recalculating the same subtrees multiple times. This dramatically reduces the time complexity.

Recursive Generation

⏱️ Time: O(4ⁿ) Space: O(4ⁿ)

For each valid split of n nodes, recursively generate all possible left and right subtrees, then combine them. A full binary tree needs odd number of nodes (1 root + even children).

Memoized Recursion — Algorithm Steps

Create a memoization cache (map/dictionary)
Check cache before computing
If not cached, compute recursively as before
Store result in cache before returning

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Cache

Look up if result for n is already computed

Cache Hit

Return stored result immediately if found

Cache Miss

Compute recursively and store result

Reuse

Subsequent calls use cached results

Code -

solution.c — C

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

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

struct MemoEntry {
    int n;
    struct TreeNode** trees;
    int count;
};

struct MemoEntry memo[50];
int memoSize = 0;

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

struct MemoEntry* findMemo(int n) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].n == n) {
            return &memo[i];
        }
    }
    return NULL;
}

struct TreeNode** solution(int n, int* returnSize) {
    struct MemoEntry* cached = findMemo(n);
    if (cached) {
        *returnSize = cached->count;
        return cached->trees;
    }
    
    *returnSize = 0;
    if (n % 2 == 0) {
        memo[memoSize].n = n;
        memo[memoSize].trees = NULL;
        memo[memoSize].count = 0;
        memoSize++;
        return NULL;
    }
    
    if (n == 1) {
        struct TreeNode** result = (struct TreeNode**)malloc(sizeof(struct TreeNode*));
        result[0] = createNode(0);
        memo[memoSize].n = n;
        memo[memoSize].trees = result;
        memo[memoSize].count = 1;
        memoSize++;
        *returnSize = 1;
        return result;
    }
    
    struct TreeNode** result = (struct TreeNode**)malloc(1000 * sizeof(struct TreeNode*));
    int count = 0;
    
    for (int leftCount = 1; leftCount < n; leftCount += 2) {
        int rightCount = n - 1 - leftCount;
        
        int leftSize, rightSize;
        struct TreeNode** leftTrees = solution(leftCount, &leftSize);
        struct TreeNode** rightTrees = solution(rightCount, &rightSize);
        
        for (int i = 0; i < leftSize; i++) {
            for (int j = 0; j < rightSize; j++) {
                struct TreeNode* root = createNode(0);
                root->left = leftTrees[i];
                root->right = rightTrees[j];
                result[count++] = root;
            }
        }
    }
    
    memo[memoSize].n = n;
    memo[memoSize].trees = result;
    memo[memoSize].count = count;
    memoSize++;
    
    *returnSize = count;
    return result;
}

void printTreeArray(struct TreeNode* root) {
    if (!root) {
        printf("[]");
        return;
    }
    
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int values[1000];
    int isNull[1000];
    int size = 0;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        if (node) {
            values[size] = node->val;
            isNull[size] = 0;
            size++;
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            values[size] = 0;
            isNull[size] = 1;
            size++;
        }
    }
    
    // Remove trailing nulls
    while (size > 0 && isNull[size - 1]) {
        size--;
    }
    
    printf("[");
    for (int i = 0; i < size; i++) {
        if (i > 0) printf(",");
        if (isNull[i]) {
            printf("null");
        } else {
            printf("%d", values[i]);
        }
    }
    printf("]");
}

int main() {
    int n;
    scanf("%d", &n);
    
    int returnSize;
    struct TreeNode** trees = solution(n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printTreeArray(trees[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4ⁿ/n³/²)

Catalan number sequence with memoization reduces redundant calculations significantly

✓ Linear Growth

Space Complexity

O(4ⁿ/n³/²)

Cache storage plus recursion stack and all generated trees

✓ Linear Space

89.4K Views

Medium Frequency

~25 min Avg. Time

2.2K 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

Constraints

Visualization

Related Problems

Common Approaches

Memoized Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler