Open In App

Flatten a multi-level linked list (Depth wise)

Last Updated : 10 Dec, 2024
Summarize
Comments
Improve
Suggest changes
Share
Like Article
Like
Report

Given a linked list where in addition to the next pointer, each node has a child pointer, which may or may not point to a separate list. These child lists may have one or more children of their own to produce a multilevel linked list. Given the head of the first level of the list. The task is to flatten the list so that all the nodes appear in a single-level linked list. Flatten the list in a way that all nodes at the first level should come first, then nodes of the second level, and so on.

Examples:

Input:

2_5


Output: 1->4->6->2->5->7->3->8
Explanation: The multilevel linked list is flattened as it has no child pointers.

We have discussed flattening of a multi-level linked list where nodes have two pointers down and next. In the previous post, we flattened the linked list level-wise. How to flatten a linked list when we always need to process the down pointer before next at every node.

Table of Content

[Expected Approach] Using Recursion - O(n) Time and O(n) Space

The approach is to recursively flatten a multi-level linked list by traversing each node and its child nodes. First, flatten the child list using recursion. Once the child list is flattened, proceed to the next node in the sequence. During traversal, maintain a reference to the previously visited node and link it to the current node. This process ensures all nodes, from different levels, are connected in a single linear list while preserving the depth-wise order.

C++ 
// A C++ program to flatten a multi-
// linked list depth-wise
#include <bits/stdc++.h>
using namespace std;

class Node {
  public:
    int data;
    Node *next;
    Node *down;
    Node(int x) {
        data = x;
        next = down = nullptr;
    }
};

void flattenList(Node *curr, Node *&prev) {
    if (curr == nullptr)
        return;

    // Add the current element to the list.
    if (prev != nullptr)
        prev->next = curr;
    prev = curr;

    // Store the next pointer
    Node *next = curr->next;

    // Recursively add the bottom list
    flattenList(curr->down, prev);

    // Recursively add the next list
    flattenList(next, prev);
}

void printList(Node *head) {
    Node *curr = head;
    while (curr != nullptr) {
        cout << curr->data << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {

    // Create a hard coded multi-linked list.
    // 5 -> 10 -> 19 -> 28
    // |           |
    // 7           22
    // |           |
    // 8           50
    // |
    // 30
    Node *head = new Node(5);
    head->down = new Node(7);
    head->down->down = new Node(8);
    head->down->down->down = new Node(30);
    head->next = new Node(10);
    head->next->next = new Node(19);
    head->next->next->down = new Node(22);
    head->next->next->down->down = new Node(50);
    head->next->next->next = new Node(28);

    Node *prev = nullptr;
    flattenList(head, prev);
    printList(head);

    return 0;
}
Java 
// A Java program to flatten a multi-
// linked list depth-wise
class Node {
    int data;
    Node next, down;

    Node(int x) {
        data = x;
        next = down = null;
    }
}

class GfG {
    
    static void flattenList(Node curr, Node[] prev) {
        if (curr == null)
            return;

        // Add the current element to the list.
        if (prev[0] != null)
            prev[0].next = curr;
        prev[0] = curr;

        // Store the next pointer
        Node next = curr.next;

        // Recursively add the bottom list
        flattenList(curr.down, prev);

        // Recursively add the next list
        flattenList(next, prev);
    }

    static void printList(Node head) {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data + " ");
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        
        // Create a hard coded multi-linked list.
        // 5 -> 10 -> 19 -> 28
        // |           |
        // 7           22
        // |           |
        // 8           50
        // |
        // 30
        Node head = new Node(5);
        head.down = new Node(7);
        head.down.down = new Node(8);
        head.down.down.down = new Node(30);
        head.next = new Node(10);
        head.next.next = new Node(19);
        head.next.next.down = new Node(22);
        head.next.next.down.down = new Node(50);
        head.next.next.next = new Node(28);

        Node[] prev = new Node[1];
        flattenList(head, prev);
        printList(head);
    }
}
Python 
# A Python program to flatten a multi-
# linked list depth-wise
class Node:
    def __init__(self, x):
        self.data = x
        self.next = None
        self.down = None

def flatten_list(curr, prev):
    if curr is None:
        return

    # Add the current element to the list.
    if prev[0] is not None:
        prev[0].next = curr
    prev[0] = curr

    # Store the next pointer
    next_node = curr.next

    # Recursively add the bottom list
    flatten_list(curr.down, prev)

    # Recursively add the next list
    flatten_list(next_node, prev)

def print_list(head):
    curr = head
    while curr is not None:
        print(curr.data, end=" ")
        curr = curr.next
    print()

if __name__ == "__main__":
    
    # Create a hard coded multi-linked list.
    # 5 -> 10 -> 19 -> 28
    # |           |
    # 7           22
    # |           |
    # 8           50
    # |
    # 30
    head = Node(5)
    head.down = Node(7)
    head.down.down = Node(8)
    head.down.down.down = Node(30)
    head.next = Node(10)
    head.next.next = Node(19)
    head.next.next.down = Node(22)
    head.next.next.down.down = Node(50)
    head.next.next.next = Node(28)

    prev = [None]
    flatten_list(head, prev)
    print_list(head)
C# 
// A C# program to flatten a multi-
// linked list depth-wise
using System;

class Node {
    public int data;
    public Node next, down;

    public Node(int x) {
        data = x;
        next = down = null;
    }
}

class GfG {

    static void FlattenList(Node curr, ref Node prev) {
        if (curr == null)
            return;

        // Add the current element to the list.
        if (prev != null)
            prev.next = curr;
        prev = curr;

        // Store the next pointer
        Node next = curr.next;

        // Recursively add the bottom list
        FlattenList(curr.down, ref prev);

        // Recursively add the next list
        FlattenList(next, ref prev);
    }

    static void PrintList(Node head) {
        Node curr = head;
        while (curr != null) {
            Console.Write(curr.data + " ");
            curr = curr.next;
        }
        Console.WriteLine();
    }

    static void Main(string[] args) {

        // Create a hard coded multi-linked list.
        // 5 -> 10 -> 19 -> 28
        // |           |
        // 7           22
        // |           |
        // 8           50
        // |
        // 30
        Node head = new Node(5);
        head.down = new Node(7);
        head.down.down = new Node(8);
        head.down.down.down = new Node(30);
        head.next = new Node(10);
        head.next.next = new Node(19);
        head.next.next.down = new Node(22);
        head.next.next.down.down = new Node(50);
        head.next.next.next = new Node(28);

        Node prev = null;

        FlattenList(head, ref prev);

        PrintList(head);
    }
}
JavaScript 
// A Javascript program to flatten a multi-
// linked list depth-wise
class Node {
    constructor(x) {
        this.data = x;
        this.next = null;
        this.down = null;
    }
}

function flattenList(curr, prev) {
    if (curr === null) return;

    // Add the current element to the list.
    if (prev[0] !== null) prev[0].next = curr;
    prev[0] = curr;

    // Store the next pointer
    let next = curr.next;

    // Recursively add the bottom list
    flattenList(curr.down, prev);

    // Recursively add the next list
    flattenList(next, prev);
}

function printList(head) {
    let curr = head;
    while (curr !== null) {
        console.log(curr.data);
        curr = curr.next;
    }
}

// Create a hard coded multi-linked list.
// 5 -> 10 -> 19 -> 28
// |           |
// 7           22
// |           |
// 8           50
// |
// 30
let head = new Node(5);
head.down = new Node(7);
head.down.down = new Node(8);
head.down.down.down = new Node(30);
head.next = new Node(10);
head.next.next = new Node(19);
head.next.next.down = new Node(22);
head.next.next.down.down = new Node(50);
head.next.next.next = new Node(28);

let prev = [null];
flattenList(head, prev);
printList(head);

Output
5 7 8 30 10 19 22 50 28

[Alternate Approach] Using Stack - O(n) Time and O(n) Space

The approach is to traverse the multi-level linked list using a stack. Start by pushing the head node onto the stack. Then, while the stack is not empty, pop the top node and process it. For each node, push its next and down pointers (if they exist) onto the stack. During this process, link the current node to the previous node, maintaining the list in a flattened form. The traversal ensures that nodes from all levels are connected in a single-level linked list, preserving the depth-wise order.

C++ 
// A C++ program to flatten a multi-
// linked list depth-wise using stack
#include <bits/stdc++.h>
using namespace std;

class Node {
  public:
    int data;
    Node *next;
    Node *down;
    Node(int x) {
        data = x;
        next = down = nullptr;
    }
};

void flattenList(Node *head) {
    if (head == nullptr)
        return;

    stack<Node *> st;
    st.push(head);
    Node *prev = nullptr;

    while (!st.empty()) {
        Node *curr = st.top();
        st.pop();

        // Push the next node first
        if (curr->next != nullptr)
            st.push(curr->next);

        // Push the bottom node into stack
        if (curr->down != nullptr)
            st.push(curr->down);

        // Add the current element to the list
        if (prev != nullptr)
            prev->next = curr;

        prev = curr;
    }
}
void printList(Node *head) {
    Node *curr = head;
    while (curr != nullptr) {
        cout << curr->data << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {

    // Create a hard coded multi-linked list.
    // 5 -> 10 -> 19 -> 28
    // |           |
    // 7           22
    // |           |
    // 8           50
    // |
    // 30
    Node *head = new Node(5);
    head->down = new Node(7);
    head->down->down = new Node(8);
    head->down->down->down = new Node(30);
    head->next = new Node(10);
    head->next->next = new Node(19);
    head->next->next->down = new Node(22);
    head->next->next->down->down = new Node(50);
    head->next->next->next = new Node(28);

    flattenList(head);

    printList(head);

    return 0;
}
Java 
// A Java program to flatten a multi-
// linked list depth-wise using stack
import java.util.Stack;

class Node {
    int data;
    Node next, down;

    Node(int x) {
        data = x;
        next = down = null;
    }
}

class GfG {

    static void flattenList(Node head) {
        if (head == null)
            return;

        Stack<Node> stack = new Stack<>();
        stack.push(head);
        Node prev = null;

        while (!stack.isEmpty()) {
            Node curr = stack.pop();

            // Push the next node first
            if (curr.next != null)
                stack.push(curr.next);

            // Push the bottom node into stack
            if (curr.down != null)
                stack.push(curr.down);

            // Add the current element to the list
            if (prev != null)
                prev.next = curr;

            prev = curr;
        }
    }

    static void printList(Node head) {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data + " ");
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {

        // Create a hard coded multi-linked list.
        // 5 -> 10 -> 19 -> 28
        // |           |
        // 7           22
        // |           |
        // 8           50
        // |
        // 30
        Node head = new Node(5);
        head.down = new Node(7);
        head.down.down = new Node(8);
        head.down.down.down = new Node(30);
        head.next = new Node(10);
        head.next.next = new Node(19);
        head.next.next.down = new Node(22);
        head.next.next.down.down = new Node(50);
        head.next.next.next = new Node(28);

        flattenList(head);
        printList(head);
    }
}
Python 
# A Python program to flatten a multi-
# linked list depth-wise using stack
class Node:
    def __init__(self, x):
        self.data = x
        self.next = None
        self.down = None

def flatten_list(head):
    if head is None:
        return

    stack = [head]
    prev = None

    while stack:
        curr = stack.pop()

        # Push the next node first
        if curr.next:
            stack.append(curr.next)

        # Push the bottom node into stack
        if curr.down:
            stack.append(curr.down)

        # Add the current element to the list
        if prev:
            prev.next = curr

        prev = curr

def print_list(head):
    curr = head
    while curr:
        print(curr.data, end=" ")
        curr = curr.next
    print()

if __name__ == "__main__":
    
    # Create a hard coded multi-linked list.
    # 5 -> 10 -> 19 -> 28
    # |           |
    # 7           22
    # |           |
    # 8           50
    # |
    # 30
    head = Node(5)
    head.down = Node(7)
    head.down.down = Node(8)
    head.down.down.down = Node(30)
    head.next = Node(10)
    head.next.next = Node(19)
    head.next.next.down = Node(22)
    head.next.next.down.down = Node(50)
    head.next.next.next = Node(28)
    
    flatten_list(head)
    print_list(head)
C# 
// A C# program to flatten a multi-
// linked list depth-wise using stack
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node next, down;

    public Node(int x) {
        data = x;
        next = down = null;
    }
}

class GfG {

    static void FlattenList(Node head) {
        if (head == null)
            return;

        Stack<Node> stack = new Stack<Node>();
        stack.Push(head);
        Node prev = null;

        while (stack.Count > 0) {
            Node curr = stack.Pop();

            // Push the next node first
            if (curr.next != null)
                stack.Push(curr.next);

            // Push the bottom node into stack
            if (curr.down != null)
                stack.Push(curr.down);

            // Add the current element to the list
            if (prev != null)
                prev.next = curr;

            prev = curr;
        }
    }

    static void PrintList(Node head) {
        Node curr = head;
        while (curr != null) {
            Console.Write(curr.data + " ");
            curr = curr.next;
        }
        Console.WriteLine();
    }

    static void Main(string[] args) {
        
        // Create a hard coded multi-linked list.
        // 5 -> 10 -> 19 -> 28
        // |           |
        // 7           22
        // |           |
        // 8           50
        // |
        // 30
        Node head = new Node(5);
        head.down = new Node(7);
        head.down.down = new Node(8);
        head.down.down.down = new Node(30);
        head.next = new Node(10);
        head.next.next = new Node(19);
        head.next.next.down = new Node(22);
        head.next.next.down.down = new Node(50);
        head.next.next.next = new Node(28);
        
        FlattenList(head);
        PrintList(head);
    }
}
JavaScript 
// A Javascript program to flatten a multi-
// linked list depth-wise using stack
class Node {
    constructor(x) {
        this.data = x;
        this.next = null;
        this.down = null;
    }
}

function flattenList(head) {
    if (head === null) return;

    let stack = [head];
    let prev = null;

    while (stack.length > 0) {
        let curr = stack.pop();

        // Push the next node first
        if (curr.next !== null) stack.push(curr.next);

        // Push the bottom node into stack
        if (curr.down !== null) stack.push(curr.down);

        // Add the current element to the list
        if (prev !== null) prev.next = curr;

        prev = curr;
    }
}

function printList(head) {
    let curr = head;
    while (curr !== null) {
        console.log(curr.data);
        curr = curr.next;
    }
}

// Create a hard coded multi-linked list.
// 5 -> 10 -> 19 -> 28
// |           |
// 7           22
// |           |
// 8           50
// |
// 30
let head = new Node(5);
head.down = new Node(7);
head.down.down = new Node(8);
head.down.down.down = new Node(30);
head.next = new Node(10);
head.next.next = new Node(19);
head.next.next.down = new Node(22);
head.next.next.down.down = new Node(50);
head.next.next.next = new Node(28);

flattenList(head);
printList(head);

Output
5 7 8 30 10 19 22 50 28

Next Article
Flatten a binary tree into linked list

K

kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox