Encode N-ary Tree to Binary Tree - Practice Coding Problems

Encode N-ary Tree to Binary Tree - Problem

Design an Algorithm to Transform N-ary Trees into Binary Trees

You're tasked with creating a reversible transformation system that can convert any N-ary tree (where nodes can have unlimited children) into a binary tree (where nodes have at most 2 children), and then convert it back to the original structure.

🌳 The Challenge: An N-ary tree allows nodes to have any number of children, while binary trees restrict each node to at most 2 children. Your encoding must preserve all structural information so that decoding produces the exact original tree.

Input: Root of an N-ary tree where each node has a value and a list of children
Output: A pair of functions - encode() that converts N-ary to binary tree, and decode() that converts back to N-ary tree

Example: If you have a tree with root 1 having children [2,3,4], your encoding should create a binary tree that can be decoded back to this exact structure.

💡 Key Insight: You have complete freedom in how you structure the binary tree representation - be creative!

Input & Output

example_1.py — Basic N-ary Tree

$ Input: Root = 1, children = [3, 2, 4]

› Output: Binary tree with 1 as root, left=3, and 3.right=2, 2.right=4

💡 Note: The N-ary tree with root 1 having three children [3,2,4] gets encoded where node 1's left points to first child (3), and the siblings 2 and 4 are chained via right pointers: 3→2→4

example_2.py — Nested Children

$ Input: Root = 1, children = [3, 2, 4], where 3 has children = [5, 6]

› Output: Binary tree preserving all relationships through first-child-next-sibling encoding

💡 Note: Node 3's children [5,6] are encoded as 3.left=5 and 5.right=6, while maintaining the sibling chain 3→2→4 at the upper level. The pattern applies recursively at each level.

example_3.py — Single Node

$ Input: Root = 1, children = []

› Output: Binary tree with single node 1, left=null, right=null

💡 Note: Edge case where N-ary tree has no children results in a binary tree node with no left or right children, demonstrating the encoding handles leaf nodes correctly.

Constraints

The height of the n-ary tree is less than or equal to 1000
The total number of nodes is between [0, 10⁴]
Do not use class member/global/static variables to store states
Your encode and decode algorithms should be stateless

Visualization

Tap to expand

Understanding the Visualization

Original N-ary Structure

Each node can have unlimited children arranged in a list

Apply Binary Constraint

Each node now has only two pointers: left and right

Left = First Child

The left pointer always points to the first child in the original list

Right = Next Sibling

The right pointer chains siblings together horizontally

Recursive Application

This pattern applies to every node in the tree, preserving all relationships

Key Takeaway

🎯 Key Insight: The first-child-next-sibling pattern is a classic technique that elegantly converts any tree structure into binary format while preserving all relationships. This approach is optimal in both time O(n) and space O(h) complexity.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses the first child, next sibling encoding pattern. For each N-ary node, the binary tree's left pointer points to the first child, and the right pointer chains siblings together. This elegant approach runs in O(n) time and uses optimal O(h) space, where h is the tree height. The key insight is that this pattern naturally preserves all structural relationships while efficiently utilizing the binary tree's two-pointer structure.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Child Chaining (Optimal)	O(n)	O(h)	Use 'first child, next sibling' encoding pattern with DFS traversal
Brute Force (Serialize/Deserialize)	O(n²)	O(n²)	Convert tree to string representation stored in binary tree nodes

DFS with Child Chaining (Optimal) — Algorithm Steps

For encoding: left pointer = first child, right pointer = next sibling
Recursively apply this pattern to all nodes using DFS
For decoding: reconstruct N-ary tree by following left pointers for children and right pointers for siblings
Handle null cases properly at each level

Visualization

Tap to expand

Step-by-Step Walkthrough

N-ary Structure

Original tree with node 1 having children 3, 2, 4

Apply Encoding Rule

Left pointer goes to first child (3), right pointer chains siblings

Binary Result

Clean binary tree that preserves all N-ary relationships

Code -

solution.c — C

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

typedef struct NaryNode {
    int val;
    struct NaryNode** children;
    int childrenSize;
} NaryNode;

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

NaryNode* createNaryNode(int val) {
    NaryNode* node = (NaryNode*)malloc(sizeof(NaryNode));
    node->val = val;
    node->children = NULL;
    node->childrenSize = 0;
    return node;
}

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

BinaryNode* encode(NaryNode* root) {
    if (!root) return NULL;
    
    BinaryNode* binaryRoot = createBinaryNode(root->val);
    
    if (root->childrenSize > 0) {
        binaryRoot->left = encode(root->children[0]);
        
        BinaryNode* current = binaryRoot->left;
        for (int i = 1; i < root->childrenSize; i++) {
            current->right = encode(root->children[i]);
            current = current->right;
        }
    }
    
    return binaryRoot;
}

NaryNode* decode(BinaryNode* root) {
    if (!root) return NULL;
    
    NaryNode* naryRoot = createNaryNode(root->val);
    
    // Count children first
    int childCount = 0;
    BinaryNode* temp = root->left;
    while (temp) {
        childCount++;
        temp = temp->right;
    }
    
    if (childCount > 0) {
        naryRoot->children = (NaryNode**)malloc(childCount * sizeof(NaryNode*));
        naryRoot->childrenSize = childCount;
        
        BinaryNode* current = root->left;
        int i = 0;
        while (current) {
            naryRoot->children[i++] = decode(current);
            current = current->right;
        }
    }
    
    return naryRoot;
}

int main() {
    // Create test N-ary tree
    NaryNode* root = createNaryNode(1);
    root->children = (NaryNode**)malloc(3 * sizeof(NaryNode*));
    root->childrenSize = 3;
    root->children[0] = createNaryNode(3);
    root->children[1] = createNaryNode(2);
    root->children[2] = createNaryNode(4);
    
    BinaryNode* binaryTree = encode(root);
    NaryNode* decodedTree = decode(binaryTree);
    
    printf("Root value: %d\n", decodedTree->val);
    printf("Children count: %d\n", decodedTree->childrenSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal for encoding and decoding, visiting each node exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals height of tree, optimal space usage

✓ Linear Space

82.4K Views

Medium Frequency

~25 min Avg. Time

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

DFS with Child Chaining (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler