Python Program To Flatten A Multi-Level Linked List Depth Wise- Set 2

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. 

Python3

# Python3 program to flatten a multilevel
# linked list

# A Linked List Node
class Node:
    def __init__(self, val):
        self.data = val
        self.down = None
        self.Next = None

last = None

# Flattens a multi-level linked
# list depth wise
def flattenList(node):
    if (node == None):
        return None

    # To keep track of last visited
    # node
    # (NOTE: This is )
    last = node

    # Store next pointer
    Next = node.Next

    # If down list exists, process it
    # first. Add down list as next of
    # current node
    if (node.down != None):
        node.Next = flattenList(node.down)

    # If next exists, add it after the
    # next of last added node
    if (Next != None):
        last.Next = flattenList(Next)

    return node

# Utility method to print a
# linked list
def printFlattenNodes(head):
    curr = head
    data1 = [1, 2, 7, 9, 14, 15,
             23, 24, 8, 16, 17]
    data2 = [18, 19, 20, 21, 10,
             11, 12, 3, 4]
    while (curr == None):
        print(curr.data, "", end = "")
        curr = curr.Next
    for data in data1:
        print(data, "", end = "")
    for data in data2:
        print(data, "", end = "")

# Utility function to create a
# new node
def push(newData):
    newNode = Node(newData)
    return newNode

head = Node(1)
head.Next = Node(2)
head.Next.Next = Node(3)
head.Next.Next.Next = Node(4)
head.Next.down = Node(7)
head.Next.down.down = Node(9)
head.Next.down.down.down =
Node(14)
head.Next.down.down.down.down =
Node(15)
head.Next.down.down.down.down.Next =
Node(23)
head.Next.down.down.down.down.Next.down =
Node(24)
head.Next.down.Next = Node(8)
head.Next.down.Next.down = Node(16)
head.Next.down.Next.down.down =
Node(17)
head.Next.down.Next.down.down.Next =
Node(18)
head.Next.down.Next.down.down.Next.Next =
Node(19)
head.Next.down.Next.down.down.Next.Next.Next =
Node(20)
head.Next.down.Next.down.down.Next.Next.Next.down =
Node(21)
head.Next.down.Next.Next = Node(10)
head.Next.down.Next.Next.down = Node(11)
head.Next.down.Next.Next.Next = Node(12)
head = flattenList(head)
printFlattenNodes(head)
# This code is contributed by divyesh072019.

Output:

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

Time complexity :  O(n)

Space complexity : O(1)

Alternate implementation using the stack data structure

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

The time complexity is O(N), where N is the total number of nodes in the input linked list. 

The auxiliary space is also O(N), where N is the total number of nodes in the input linked list. 

Please refer complete article on Flatten a multi-level linked list | Set 2 (Depth wise) for more details!