Flatten a Multilevel Doubly Linked List - Problem

You are given a doubly linked list that contains nodes with a next pointer, a prev pointer, and an additional child pointer. This child pointer may or may not point to a separate doubly linked list, which also contains these special nodes. These child lists may have one or more children of their own, creating a multilevel data structure.

Given the head of the first level of the list, flatten the list so that all nodes appear in a single-level, doubly linked list. The nodes in the child list should appear after the current node and before the current node's next node in the flattened list.

Return the head of the flattened list. All child pointers must be set to null.

Input & Output

Example 1 — Simple Multilevel

$ Input: head = [1,2,3,null,null,7,8,null,null,null,null]

› Output: [1,2,7,8,3]

💡 Note: Node 2 has child 7→8. After flattening: 1→2→7→8→3 with all child pointers set to null

Example 2 — Single Level

$ Input: head = [1,2,3,4,5]

› Output: [1,2,3,4,5]

💡 Note: No child nodes exist, so the list remains unchanged: 1→2→3→4→5

Example 3 — Empty List

$ Input: head = null

› Output: null

💡 Note: Empty list returns null

Constraints

The number of Nodes will not exceed 1000
1 ≤ Node.val ≤ 10⁵

Visualization

Tap to expand

Asked in

a Amazon 45 M Microsoft 32 in LinkedIn 28 G Google 22

The key insight is to traverse the multilevel structure and connect child branches directly into the main chain. The optimal approach uses direct pointer manipulation to find child tails and connect them without extra space. Time: O(n), Space: O(1)

Common Approaches

✓ Collect and Rebuild

⏱️ Time: O(n) Space: O(n)

First pass collects all nodes in DFS order using recursion. Second pass rebuilds the doubly linked list by connecting collected nodes sequentially and setting all child pointers to null.

DFS with Stack

⏱️ Time: O(n) Space: O(d)

Traverse the list using DFS approach. When we encounter a node with a child, we push the next node onto a stack, connect the current node to its child, and continue. When we reach the end of a branch, we pop from the stack to continue.

Two-Pointer Iteration

⏱️ Time: O(n) Space: O(1)

Traverse the list with two pointers: current for iteration and tail to track the end of flattened portion. When we find a child, we connect it to the chain and update our tail pointer to continue from the child branch.

Collect and Rebuild — Algorithm Steps

Recursively collect all nodes in DFS order
Rebuild doubly linked list from collected nodes
Set all child pointers to null

Visualization

Tap to expand

Step-by-Step Walkthrough

DFS Collection

Traverse and collect all nodes depth-first

Rebuild Links

Connect collected nodes sequentially

Clear Children

Set all child pointers to null

Code -

solution.c — C

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

typedef struct Node {
    int val;
    struct Node* prev;
    struct Node* next;
    struct Node* child;
} Node;

Node* createNode(int val) {
    Node* node = malloc(sizeof(Node));
    node->val = val;
    node->prev = NULL;
    node->next = NULL;
    node->child = NULL;
    return node;
}

Node* nodes[1000];
int nodeCount = 0;

void collect(Node* node) {
    if (!node) return;
    nodes[nodeCount++] = node;
    if (node->child) collect(node->child);
    if (node->next) collect(node->next);
}

Node* solution(Node* head) {
    if (!head) return NULL;
    
    nodeCount = 0;
    collect(head);
    
    for (int i = 0; i < nodeCount; i++) {
        nodes[i]->child = NULL;
        nodes[i]->prev = (i > 0) ? nodes[i-1] : NULL;
        nodes[i]->next = (i < nodeCount-1) ? nodes[i+1] : NULL;
    }
    
    return nodes[0];
}

Node* arrayToMultilevelList(int* arr, int size) {
    if (size == 0) return NULL;
    
    Node* nodeMap[10000] = {NULL};
    for (int i = 0; i < size; i++) {
        nodeMap[arr[i]] = createNode(arr[i]);
    }
    
    Node* prevNode = NULL;
    Node* head = NULL;
    for (int i = 0; i < size; i++) {
        if (!head) head = nodeMap[arr[i]];
        if (prevNode) {
            prevNode->next = nodeMap[arr[i]];
            nodeMap[arr[i]]->prev = prevNode;
        }
        prevNode = nodeMap[arr[i]];
    }
    
    return head;
}

int listToArray(Node* head, int* result) {
    int count = 0;
    Node* current = head;
    while (current) {
        result[count++] = current->val;
        current = current->next;
    }
    return count;
}

int parseArray(char* json, int* arr) {
    if (strcmp(json, "[]") == 0) return 0;
    
    int count = 0;
    char* ptr = json + 1; // skip [
    
    while (*ptr && *ptr != ']') {
        if (*ptr >= '0' && *ptr <= '9') {
            arr[count++] = strtol(ptr, &ptr, 10);
        } else {
            ptr++;
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int arr[1000];
    int size = parseArray(line, arr);
    
    Node* head = arrayToMultilevelList(arr, size);
    Node* resultHead = solution(head);
    
    int result[1000];
    int resultSize = listToArray(resultHead, result);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during collection, then once more during rebuild

✓ Linear Growth

Space Complexity

O(n)

Store all n nodes in an array plus recursion stack depth

⚡ Linearithmic Space

124.5K Views

Medium Frequency

~25 min Avg. Time

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

Flatten a Multilevel Doubly Linked List - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Collect and Rebuild — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler