Flatten a Multilevel Doubly Linked List - Practice Coding Problems

Flatten a Multilevel Doubly Linked List - Problem

Transform a Multi-Level Maze into a Single Path

Imagine you have a doubly linked list that's not just a simple chain, but a complex multi-level structure! Each node can have:

next - pointer to the next node
prev - pointer to the previous node
child - pointer to a separate doubly linked list branch

Your mission is to flatten this multilevel structure into a single-level doubly linked list. The key rule: when you encounter a node with a child, the entire child branch should be inserted between the current node and its next node.

Think of it like exploring a building with multiple floors - you want to create a single path that visits every room in a depth-first manner, then return to continue the main corridor.

Requirements:

All child pointers must be set to null in the final result
Maintain proper prev and next connections
Return the head of the flattened list

Input & Output

example_1.py — Python

$ Input: head = [1,2,3,4,5,6,null,null,null,7,8,11,12,null,null,null,null] Multilevel structure: 1---2---3---4---5---6--NULL | 7---8---11--12--NULL

› Output: [1,2,3,7,8,11,12,4,5,6] Flattened: 1<->2<->3<->7<->8<->11<->12<->4<->5<->6

💡 Note: Node 3 has a child pointing to node 7. The child branch (7,8,11,12) is inserted between node 3 and node 4 in depth-first order.

example_2.py — Python

$ Input: head = [1,2,null,3,null,null,null] Multilevel structure: 1---2--NULL | 3--NULL

› Output: [1,3,2] Flattened: 1<->3<->2

💡 Note: Node 1 has a child pointing to node 3. Since node 1's child branch contains only node 3, it's inserted between node 1 and node 2.

example_3.py — Python

$ Input: head = [1,2,3,4,5,6,null,null,null,7,8,null,null,9,10,null,null] Complex multilevel with nested children

› Output: [1,2,3,7,8,9,10,4,5,6] Flattened result with all levels merged in DFS order

💡 Note: Multiple levels of children are processed depth-first: when we encounter a child, we fully explore its subtree before continuing with the main branch.

Constraints

The number of nodes in the list is in the range [0, 1000]
1 ≤ Node.val ≤ 10⁵
All child pointers must be set to null in the result
The input multilevel linked list is well-formed (no cycles)

Visualization

Tap to expand

Understanding the Visualization

Enter Room with Stairs

When you find a room with stairs (child pointer), write down where you would have gone next on a sticky note

Explore Sub-floor Completely

Go down the stairs and explore that entire floor, connecting rooms as you go

Return Using Sticky Note

When you reach a dead end, use your sticky note to return and continue the main path

Repeat Until Done

Continue this process until you've visited every room and created one continuous path

Key Takeaway

🎯 Key Insight: A stack naturally handles the 'return address' problem in multilevel structures, enabling efficient depth-first flattening in a single pass.

Asked in

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

The optimal solution uses a stack-based iterative approach to flatten the multilevel doubly linked list in O(n) time and O(d) space, where d is the maximum depth. Key insight: when encountering a node with a child, push the next node onto the stack, connect to the child immediately, and pop from the stack when reaching the end of a branch. This maintains the depth-first traversal order while processing the structure in a single pass.

Common Approaches

Approach	Time	Space	Notes
✓ Iterative with Stack (Optimal)	O(n)	O(d)	Use a stack to track continuation points while flattening in place
Brute Force (Multiple Traversals)	O(n)	O(n)	Collect all nodes in a list, then rebuild connections sequentially

Iterative with Stack (Optimal) — Algorithm Steps

Initialize a stack and start with the head node
For each node with a child: push the next node to stack, connect current to child
Set child pointer to null and update prev pointers properly
When reaching end of current branch, pop from stack to continue
Repeat until both current node and stack are empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Encounter Child

When current node has a child, push next node to stack and connect to child

Process Child Branch

Continue processing the child branch until reaching its end

Pop and Continue

When branch ends, pop from stack to reconnect and continue main path

Code -

solution.c — C

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

struct Node* flatten(struct Node* head) {
    if (!head) return head;
    
    struct Node* stack[1000]; // Assuming max depth 1000
    int stackTop = -1;
    struct Node* current = head;
    
    while (current) {
        if (current->child) {
            // If there's a next node, save it for later
            if (current->next) {
                stack[++stackTop] = current->next;
            }
            
            // Connect current node to its child
            current->next = current->child;
            current->child->prev = current;
            current->child = NULL; // Clear child pointer
        }
        
        // If we've reached the end of current branch and have saved nodes
        if (!current->next && stackTop >= 0) {
            struct Node* nextNode = stack[stackTop--];
            current->next = nextNode;
            nextNode->prev = current;
        }
        
        current = current->next;
    }
    
    return head;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during the flattening process

✓ Linear Growth

Space Complexity

O(d)

Stack space proportional to maximum depth d of child branches

✓ Linear Space

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

Transform a Multi-Level Maze into a Single Path

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Iterative with Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler