Flattening of Linked List Python

If we are given a linked list with each node being a separate linked list and two pointers of the same type:

One pointer points towards the next node of the primary linked list (referred to as the 'prim' pointer in the program below).
One pointer points towards the next node of the secondary linked list (the 'sec' pointer in the program below).

Every linked list, primary and secondary, should be sorted, and the resulting linked list, which will be a flat linked list, should also be sorted.

Examples

Input:

      6 ->   15 ->   21 ->   29
      |      |       |       |
      V      V       V       V
      7      25      26      30
      |      |       |
      V      V       V
      9      51      31
      |      |
      V      V
      30     56

Output:

6 -> 7 -> 9 -> 15 -> 21 -> 25 -> 26 -> 29 -> 30 -> 30 -> 31 -> 51 -> 56

Input:

      4 ->   5 ->   9 ->   17
      |      |      |      |
      V      V      V      V
      10     8      15     21
      |      |   
      V      V  
      15     30

Output:

4 -> 5 -> 8 -> 9 -> 10 -> 15 -> 15 -> 17 -> 21 -> 30

The strategy is to define a function to merge the linked lists. We will merge the lists sequentially using the merge() function, recursively merging the current linked list to the recently flattened list. We will use the sec pointer to connect flattened list nodes.

The algorithm of the problem is as follows:

We will recursively merge the current iteration's linked list to the subsequent linked list.
If the linked list of the current iteration does not have any nodes, i.e., it is empty, or the next linked list is None, the linked list of the current iteration is returned. This condition will serve as the base condition.
We will begin combining the linked lists with the most recent ones.
We will return the head of the linked list of the current iteration after merging the present and the previously flattened linked list.

The mentioned technique is implemented as follows:

Code

# Python program to flatten a linked list using the merging technique

# Creating a node class for a nested linked list.
# It will have prim and sec pointers to point towards the next node of the main and the secondary linked list, respectively.
class Node():
   def __init__(self, val):
     self.val = val
     self.prim = None
     self.sec = None

# Creating the constructor class for the linked list
class LinkedList():

   # This class will initialize a head node
   def __init__(self):
     self.head = None

   # Defining a function to insert a node at the beginning of a linked list
   def insert(self, head, val):

     # Creating a node and giving it the value that needs to be inserted
     node = Node(val)

     # Making the next newly created Node as the head
     node.sec = head

     # Moving the head pointer to point to the newly created Node
     head = node

     # returning the head of the linked list after inserting an element
     return head

   # Defining a function to print the linked list
   def printList(self):
     t = self.head
     while(t != None):
       print(t.val, end = " ")
       t = t.sec

     print()

   # Defining the function to merge two sorted linked lists
   def merge(self, a, b):
     # If the first list is empty, then the second linked list is the answer
     if a == None:
       return b

     # If the second list is empty, then the first linked list is the answer
     if(a == None):
       return b

     # Comparing the values of the two linked lists and putting the larger value in the output
     output = None

     if (a.val < b.val):
       output = a
       output.sec = self.merge(a.sec, b)
     else:
       output = b
       output.sec = self.merge(a, b.sec)

     output.prim = None
     return output

   # Defining a function to recursively use the merge() function to merge current and the already flattened linked lists
   def flattened(self, r):

     # Base condition
     if r == None or r.prim == None:
       return r
     
     # recursively calling the function for the primary linked list

     r.prim = self.flattened(r.prim)

     # Now merging the two linked lists
     r = self.merge(r, r.prim)

     # returning the root, which will be merged to the secondary linked list
     return r


# Calling the function
llist = LinkedList()

'''
Let us use the following linked list, for example
             6 -> 15 -> 21 -> 29
             |       |        |       |
             V      V        V      V
             7     25      26     30
             |       |        |
             V      V        V
             9     51       31
             |       |
             V      V
            30    56

'''
llist.head = llist.insert(llist.head, 30)
llist.head = llist.insert(llist.head, 9)
llist.head = llist.insert(llist.head, 7)
llist.head = llist.insert(llist.head, 6)

llist.head.prim = llist.insert(llist.head.prim, 25)
llist.head.prim = llist.insert(llist.head.prim, 15)

llist.head.prim.prim = llist.insert(llist.head.prim.prim, 51)
llist.head.prim.prim = llist.insert(llist.head.prim.prim, 26)
llist.head.prim.prim = llist.insert(llist.head.prim.prim, 21)

llist.head.prim.prim.prim = llist.insert(llist.head.prim.prim.prim, 56)
llist.head.prim.prim.prim = llist.insert(llist.head.prim.prim.prim, 31)
llist.head.prim.prim.prim = llist.insert(llist.head.prim.prim.prim, 30)
llist.head.prim.prim.prim = llist.insert(llist.head.prim.prim.prim, 29)

# Calling the function to flatten the linked list
llist.head = llist.flattened(llist.head)

print("The flattened linked list is: ")
llist.printList()

Output:

The flattened linked list is: 
6 7 9 15 21 25 26 29 30 30 31 51 56

Time Complexity: The time complexity of this program is O(n * n * m). Here N is the total number of nodes in the primary linked list, and M represents the number of nodes of a single sub-linked list

Auxiliary Space: O(n * m).

Since we are merging two linked lists simultaneously,

When we add the first two sub-linked lists, the time complexity will be O(m + m) = O(2m).
In the next step, we will merge one more sub-linked list to the new merged linked list. Therefore, the time complexity will be O(2m + m) = O(3M).
In the next step, we will merge one more list. Therefore the time complexity will be O(3m + m).
In this way, we will continue merging the sub-linked lists to the already merged linked list.
This step will be repeated n number of times; therefore this approach will take a total time of O(2m + 3m + 4m + …. n * m) = (2 + 3 + 4 + … + n)*m
Further solving the above equation: time complexity = O((n * n + n - 2) * m / 2)
The approximation of the above equation will lead to O(n * n * m) for a large value of n

Since we are using a recursive approach, the space complexity of this approach is O(n * m). The recursive function used in this approach will create a recursive stack. The size of this stack will be equivalent to the total number of nodes present in the given nested linked list, which is n * m.

Flattening a Linked List using Priority Queues

The approach is to create a Min-Heap and place the head node of each linked list into this data structure. Then, using the Extract-min method, obtain the minimum integer from the priority queue and proceed in the linked list using that minimum element.

To implement this strategy, we will use the following algorithm:

The head node of each linked list is pushed into the Min-heap priority queue.
Then we will extract the minimum integer value node out of the priority queue while it is not empty, and if the next node points towards the minimum value node, then we will push that node into the priority queue.
Additionally, after extracting the minimum value node, we will print the node's value each time.

We will implement this algorithm in Python as follows.

Code

# Python program to flatten the linked list using the heap data structure

# Importing the required module
from heapq import heappush, heappop

# Creating the class node
class Node:
   def __init__(self, val):
     self.val = val
     self.prim = self.sec = None

# Creating the constructor class of the linked list
# This class will initialize the head node
class LinkedList():
   def __init__(self):
     # head node of the linked list
     self.head = None

   # Defining a method to insert a node at the beginning of the linked list
   def push(self, ref, value):

     # Creating a new node that is to be added
     node = Node(value)

     # Making the next of the new Node as the head node
     node.sec = ref

     # Moving the head node to point toward the new Node
     ref = node

     # Returning the head node
     return ref

   # Defining a function to print the linked list
   def printList(self):
     t = self.head
     while t != None:
       print(t.val, end = " ")
       t = t.sec

     print()


# Creating a class that will compare the two nodes
class Compare:
   def __init__(self, node):
     self.node = node

   def __lt__(self, other):
     return self.node.val < other.node.val

# Creating a method to flatten the linked list
def flattened(root):
   p_queue = []

   # Pushing the main nodes of the main linked list to the priority queue
   while root:
     heappush(p_queue, Compare(root))
     root = root.prim
   d = Node(0)
   t = d
   
   # We will pop out the minimum value node until there is no node left in the priority queue
   while p_queue:
     node = heappop(p_queue).node
     t.sec = node
     t = node
     # If the child node exists we will add that node to the priority queue
     if node.sec:
       heappush(p_queue, Compare(node.sec))

   return d.sec


# Creating the linked list
llist = LinkedList()

'''
Let us create the following linked list
             6 -> 15 -> 21 -> 29
             |       |        |       |
             V      V        V      V
             7     25      26     30
             |       |        |
             V      V        V
             9     51       31
             |       |
             V      V
            30    56

'''
llist.head = llist.push(llist.head, 6)
llist.head = llist.push(llist.head, 7)
llist.head = llist.push(llist.head, 9)
llist.head = llist.push(llist.head, 30)

llist.head.prim = llist.push(llist.head.prim, 15)
llist.head.prim = llist.push(llist.head.prim, 25)

llist.head.prim.prim = llist.push(llist.head.prim.prim, 21)
llist.head.prim.prim = llist.push(llist.head.prim.prim, 26)
llist.head.prim.prim = llist.push(llist.head.prim.prim, 51)

llist.head.prim.prim.prim = llist.push(llist.head.prim.prim.prim, 29)
llist.head.prim.prim.prim = llist.push(llist.head.prim.prim.prim, 30)
llist.head.prim.prim.prim = llist.push(llist.head.prim.prim.prim, 31)
llist.head.prim.prim.prim = llist.push(llist.head.prim.prim.prim, 56)

# Flattening the linked list
flattened(llist.head)

# Printing the flattened linked list
llist.printList()

Output:

30 9 7 6 51 26 21 56 31 30 29

Time Complexity: The time complexity of this approach is O(N * M * log(N)). Here N is the number of nodes in the main or primary linked list, and M represents the number of nodes in a single sub-linked list.

Auxiliary Space: The space complexity of this approach is O(N). Here N is the number of nodes present in the main linked list.

Next TopicApply a Function to a Single Column of a CSV in Spark

← prev next →