Flatten a multi-level linked list | Set 2 (Depth wise)

Difficulty Level : Medium
Last Updated : 19 May, 2021

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.

Input:  
1 - 2 - 3 - 4
    |
    7 -  8 - 10 - 12
    |    |    |
    9    16   11
    |    |
    14   17 - 18 - 19 - 20
    |                    |
    15 - 23             21
         |
         24

Output:        
Linked List to be flattened to
1 - 2 - 7 - 9 - 14 - 15 - 23 - 24 - 8
 - 16 - 17 - 18 - 19 - 20 - 21 - 10 - 
11 - 12 - 3 - 4
Note : 9 appears before 8 (When we are 
at a node, we process down pointer before 
right pointer)

Source: Oracle Interview

If we take a closer look, we can notice that this problem is similar to tree to linked list conversion. We recursively flatten a linked list with the following steps.
1) If the node is NULL, return NULL.
2) Store the next node of the current node (used in step 4).
3) Recursively flatten down the list. While flattening, keep track of the last visited node, so that the next list can be linked after it.
4) Recursively flatten the next list (we get the next list from the pointer stored in step 2) and attach it after the last visited node.

Below is the implementation of the above idea.

C++

// C++ program to flatten a multilevel linked list
#include <bits/stdc++.h>
using namespace std;
 
// A Linked List Node
struct Node
{
    int data;
    struct Node *next;
    struct Node *down;
};
 
// Flattens a multi-level linked list depth wise
Node* flattenList(Node* node)
{
    // Base case
    if (node == NULL)
        return NULL;
 
    // To keep track of last visited node
    // (NOTE: This is static)
    static Node *last;
    last = node;
 
    // Store next pointer
    Node *next = node->next;
 
    // If down list exists, process it first
    // Add down list as next of current node
    if (node->down)
       node->next = flattenList(node->down);
 
    // If next exists, add it after the next
    // of last added node
    if (next)
       last->next = flattenList(next);
 
    return node;
}
 
// Utility method to print a linked list
void printFlattenNodes(Node* head)
{
    while (head)
    {
    printf("%d ", head->data);
    head = head->next;
    }
    
}
 
// Utility function to create a new node
Node* newNode(int new_data)
{
    Node* new_node = new Node;
    new_node->data = new_data;
    new_node->next = new_node->down = NULL;
    return new_node;
}
 
// Driver code
int main()
{
    // Creating above example list
    Node* head = newNode(1);
    head->next = newNode(2);
    head->next->next = newNode(3);
    head->next->next->next = newNode(4);
    head->next->down = newNode(7);
    head->next->down->down = newNode(9);
    head->next->down->down->down = newNode(14);
    head->next->down->down->down->down
                                     = newNode(15);
    head->next->down->down->down->down->next
                                     = newNode(23);
    head->next->down->down->down->down->next->down
                                      = newNode(24);
    head->next->down->next = newNode(8);
    head->next->down->next->down = newNode(16);
    head->next->down->next->down->down = newNode(17);
    head->next->down->next->down->down->next
                                      = newNode(18);
    head->next->down->next->down->down->next->next
                                      = newNode(19);
    head->next->down->next->down->down->next->next->next
                                      = newNode(20);
    head->next->down->next->down->down->next->next->next->down
                                      = newNode(21);
    head->next->down->next->next = newNode(10);
    head->next->down->next->next->down = newNode(11);
 
    head->next->down->next->next->next = newNode(12);
 
    // Flatten list and print modified list
    head = flattenList(head);
    printFlattenNodes(head);
 
    return 0;
}

Java

// Java program to flatten a multilevel linked list
public class FlattenList {
 
    static Node last;
 
    // Flattens a multi-level linked list depth wise
    public static Node flattenList(Node node)
    {
        if(node==null)
            return null;
   
        // To keep track of last visited node
        // (NOTE: This is static) 
        last = node;
   
        // Store next pointer
        Node next = node.next;
   
        // If down list exists, process it first
        // Add down list as next of current node
        if(node.down!=null)
            node.next = flattenList(node.down);
   
        // If next exists, add it after the next
        // of last added node
        if(next!=null)
            last.next = flattenList(next);
   
        return node;
    }
 
    // Utility method to print a linked list
    public static void printFlattenNodes(Node head)
    {
        Node curr=head;
        while(curr!=null)
        {
            System.out.print(curr.data+" ");
            curr = curr.next;
        }
         
    }
     
    // Utility function to create a new node
    public static Node push(int newData)
    {
        Node newNode = new Node(newData);
        newNode.next =null;
        newNode.down = null;
        return newNode;
    }
     
    public static void main(String args[]) {
        Node head=new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.down = new Node(7);
        head.next.down.down = new Node(9);
        head.next.down.down.down = new Node(14);
        head.next.down.down.down.down= new Node(15);
        head.next.down.down.down.down.next= new Node(23);
        head.next.down.down.down.down.next.down = new Node(24);
        head.next.down.next = new Node(8);
        head.next.down.next.down = new Node(16);
        head.next.down.next.down.down= new Node(17);
        head.next.down.next.down.down.next= new Node(18);
        head.next.down.next.down.down.next.next= new Node(19);
        head.next.down.next.down.down.next.next.next
                                            = new Node(20);
        head.next.down.next.down.down.next.next.next.down
                                            = new Node(21);
        head.next.down.next.next = new Node(10);
        head.next.down.next.next.down = new Node(11);
        head.next.down.next.next.next = new Node(12);
 
        head = flattenList(head);
        printFlattenNodes(head);
    }
}
 
//Node of Multi-level Linked List
class Node
{
    int data;
    Node next,down;
    Node(int data)
    {
        this.data=data;
        next=null;
        down=null;
    }
}
//This code is contributed by Gaurav Tiwari

C#

// C# program to flatten a multilevel linked list
using System;
 
class FlattenList
{
 
    static Node last;
 
    // Flattens a multi-level linked list depth wise
    public static Node flattenList(Node node)
    {
        if(node == null)
            return null;
     
        // To keep track of last visited node
        // (NOTE: This is static)
        last = node;
     
        // Store next pointer
        Node next = node.next;
     
        // If down list exists, process it first
        // Add down list as next of current node
        if(node.down != null)
            node.next = flattenList(node.down);
     
        // If next exists, add it after the next
        // of last added node
        if(next != null)
            last.next = flattenList(next);
     
        return node;
    }
 
    // Utility method to print a linked list
    public static void printFlattenNodes(Node head)
    {
        Node curr = head;
        while(curr != null)
        {
            Console.Write(curr.data + " ");
            curr = curr.next;
        }
         
    }
     
    // Utility function to create a new node
    public static Node push(int newData)
    {
        Node newNode = new Node(newData);
        newNode.next =null;
        newNode.down = null;
        return newNode;
    }
     
    // Driver code
    public static void Main()
    {
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.down = new Node(7);
        head.next.down.down = new Node(9);
        head.next.down.down.down = new Node(14);
        head.next.down.down.down.down= new Node(15);
        head.next.down.down.down.down.next= new Node(23);
        head.next.down.down.down.down.next.down = new Node(24);
        head.next.down.next = new Node(8);
        head.next.down.next.down = new Node(16);
        head.next.down.next.down.down= new Node(17);
        head.next.down.next.down.down.next= new Node(18);
        head.next.down.next.down.down.next.next= new Node(19);
        head.next.down.next.down.down.next.next.next
                                            = new Node(20);
        head.next.down.next.down.down.next.next.next.down
                                            = new Node(21);
        head.next.down.next.next = new Node(10);
        head.next.down.next.next.down = new Node(11);
        head.next.down.next.next.next = new Node(12);
 
        head = flattenList(head);
        printFlattenNodes(head);
    }
}
 
// Node of Multi-level Linked List
public class Node
{
    public int data;
    public Node next,down;
    public Node(int data)
    {
        this.data = data;
        next = null;
        down = null;
    }
}
 
/* This code is contributed PrinciRaj1992 */

Javascript

<script>
 
// Javascript program to flatten
// a multilevel linked list
 
// Node of Multi-level Linked List
    class Node {
          constructor(val) {
            this.data = val;
            this.down = null;
            this.next = null;
        }
    }
    var last;
 
    // Flattens a multi-level linked
    // list depth wise
    function flattenList(node) {
        if (node == null)
            return null;
 
        // To keep track of last visited node
        // (NOTE: This is )
        last = node;
 
        // Store next pointer
        var next = node.next;
 
        // If down list exists, process it first
        // Add down list as next of current node
        if (node.down != null)
            node.next = flattenList(node.down);
 
        // If next exists, add it after the next
        // of last added node
        if (next != null)
            last.next = flattenList(next);
 
        return node;
    }
 
    // Utility method to prvar a linked list
    function printFlattenNodes(head) {
        var curr = head;
        while (curr != null) {
            document.write(curr.data + " ");
            curr = curr.next;
        }
 
    }
 
    // Utility function to create a new node
    function push(newData) {
        var newNode = new Node(newData);
        newNode.next = null;
        newNode.down = null;
        return newNode;
    }
 
     
        var head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.down = new Node(7);
        head.next.down.down = new Node(9);
        head.next.down.down.down = new Node(14);
        head.next.down.down.down.down =
        new Node(15);
        head.next.down.down.down.down.next =
        new Node(23);
        head.next.down.down.down.down.next.down =
        new Node(24);
        head.next.down.next =
        new Node(8);
        head.next.down.next.down =
        new Node(16);
        head.next.down.next.down.down =
        new Node(17);
        head.next.down.next.down.down.next =
        new Node(18);
        head.next.down.next.down.down.next.next =
        new Node(19);
        head.next.down.next.down.down.next.next.next =
        new Node(20);
        head.next.down.next.down.down.next.next.next.down =
        new Node(21);
        head.next.down.next.next = new Node(10);
        head.next.down.next.next.down = new Node(11);
        head.next.down.next.next.next = new Node(12);
 
        head = flattenList(head);
        printFlattenNodes(head);
 
 
 
// This code contributed by aashish1995
 
</script>

Output:

1 2 7 9 14 15 23 24 8 16 17 18 19 20 21 10 11 12 3 4

Alternate implementation using the stack data structure

C++

Node* flattenList2(Node* head)
{
    Node* headcop = head;
    stack<Node*> save;
    save.push(head);
    Node* prev = NULL;
 
    while (!save.empty()) {
        Node* temp = save.top();
        save.pop();
 
        if (temp->next)
            save.push(temp->next);
        if (temp->down)
            save.push(temp->down);
 
        if (prev != NULL)
            prev->next = temp;
 
        prev = temp;
    }
    return headcop;
}

Java

Node flattenList2(Node head)
{
    Node headcop = head;
    Stack<Node> save = new Stack<>();
    save.push(head);
    Node prev = null;
 
    while (!save.isEmpty()) {
        Node temp = save.peek();
        save.pop();
 
        if (temp.next)
            save.push(temp.next);
        if (temp.down)
            save.push(temp.down);
 
        if (prev != null)
            prev.next = temp;
 
        prev = temp;
    }
    return headcop;
}
 
// This code contributed by aashish1995

Python3

def flattenList2(head):
 
    headcop = head
    save = []
    save.append(head)
    prev = None
  
    while (len(save) != 0):
        temp = save[-1]
        save.pop()
  
        if (temp.next):
            save.append(temp.next)
        if (temp.down):
            save.append(temp.down)
  
        if (prev != None):
            prev.next = temp
  
        prev = temp
     
    return headcop
 
# This code is contributed by rutvik_56

C#

Node flattenList2(Node head)
{
    Node headcop = head;
    Stack<Node> save = new Stack<Node>();
    save.Push(head);
    Node prev = null;
 
    while (!save.Count != 0)
    {
        Node temp = save.Peek();
        save.Pop();
        if (temp.next)
            save.Push(temp.next);
        if (temp.down)
            save.Push(temp.down);
        if (prev != null)
            prev.next = temp;
        prev = temp;
    }
    return headcop;
}
 
 
// This code is contributed by aashish1995

Javascript

<script>
    function flattenList2(head)
    {
        var headcop = head;
          var save = new Stack();
        save.push(head);
        var prev = null;
 
        while (!save.isEmpty()) {
            var temp = save.pop();   
 
            if (temp.next)
                save.push(temp.next);
            if (temp.down)
                save.push(temp.down);
 
            if (prev != null)
                   prev.next = temp;
 
            prev = temp;
           }
        return headcop;
    }
// This code contributed by aashish1995
</script>

This article is contributed by Mu Ven. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes