Python Tutorial

In this tutorial, we will write the Python code to flattening the given linked list. A given linked list which consists of every node represents a linked list and contains two pointers of its type.

The first pointer represents the next pointer to the next node and a bottom pointer to a linked list where this node is head. Each of the sub-linked list in sorted order.

Here the flattening means that all nodes must appear in a single level while maintaining the sorted order.

Let's see the problem statement.

Problem Statement

Example -

Input:

5 -> 10 -> 19 -> 28
|     |     |     | 
7     20    22   35
|           |     | 
8          50    40
|                 | 
30               45

Output:

5-> 7-> 8- > 10 -> 19-> 20-> 22-> 28-> 30-> 35-> 40-> 45-> 50.

Example - 2:

Input:

5 -> 10 -> 19 -> 28
|          |                
7          22   
|          |                 
8          50 
|                           
30              

Output:

5->7->8->10->19->22->28->30->50

Solution

In this method, first we will convert into the regular list and then flatten the elements. Let's understand the following example.

Example -

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.child = None


def flatten_linked_list(head):
    # Convert the linked list into a regular list
    linked_list = []
    current = head
    while current:
        linked_list.append(current.data)
        current = current.next

    # Flatten the list
    flattened_list = []
    for item in linked_list:
        if isinstance(item, Node):
            flattened_list.extend(flatten_linked_list(item))
        else:
            flattened_list.append(item)

    return flattened_list


# Example linked list
head = Node(5)
head.next = Node(10)
head.next.next = Node(19)
head.next.next.next = Node(28)

head.child = Node(7)
head.child.next = Node(8)
head.child.child = Node(30)

head.next.child = Node(22)
head.next.child.next = Node(50)
# Flatten the linked list
flattened_list = flatten_linked_list(head)

# Print the flattened list
print("Flattened linked list:", flattened_list)

Output:

Flattened linked list: [5, 7, 8, 30, 10, 19, 28, 22, 50]

Explanation -

In the above code, first we created the node with the next and next to next pointer. We created the flatten_linked_list() that takes the head of the linked list as input. It converts the linked list into a regular list by traversing the linked list and appending the data of each node to the list. Then, it flattens the list by recursively calling the flatten_linked_list function on any child nodes encountered. Finally, it returns the flattened list.

The program creates the example linked list as described and then calls the flatten_linked_list() function on the head of the linked list. The resulting flattened list is printed as the output.

Example -

class Node:
    def __init__(self, data):
        self.data = data
        self.right = None
        self.down = None


class LinkedList:
    def __init__(self):
        self.head = None

    def insert_at_beginning(self, head_ref, data):
        new_node = Node(data)
        new_node.down = head_ref
        head_ref = new_node
        return head_ref

    def print_list(self):
        temp = self.head
        while temp is not None:
            print(temp.data, end=" ")
            temp = temp.down
        print()

    def merge_lists(self, a, b):
        if a is None:
            return b
        if b is None:
            return a

        result = None

        if a.data < b.data:
            result = a
            result.down = self.merge_lists(a.down, b)
        else:
            result = b
            result.down = self.merge_lists(a, b.down)

        result.right = None
        return result

    def flatten(self, root):
        if root is None or root.right is None:
            return root

        root.right = self.flatten(root.right)
        root = self.merge_lists(root, root.right)
        return root
linked_list = LinkedList()

linked_list.head = linked_list.insert_at_beginning(linked_list.head, 30)
linked_list.head = linked_list.insert_at_beginning(linked_list.head, 8)
linked_list.head = linked_list.insert_at_beginning(linked_list.head, 7)
linked_list.head = linked_list.insert_at_beginning(linked_list.head, 5)

linked_list.head.right = linked_list.insert_at_beginning(linked_list.head.right, 20)
linked_list.head.right = linked_list.insert_at_beginning(linked_list.head.right, 10)

linked_list.head.right.right = linked_list.insert_at_beginning(linked_list.head.right.right, 50)
linked_list.head.right.right = linked_list.insert_at_beginning(linked_list.head.right.right, 22)
linked_list.head.right.right = linked_list.insert_at_beginning(linked_list.head.right.right, 19)

linked_list.head.right.right.right = linked_list.insert_at_beginning(linked_list.head.right.right.right, 45)
linked_list.head.right.right.right = linked_list.insert_at_beginning(linked_list.head.right.right.right, 40)
linked_list.head.right.right.right = linked_list.insert_at_beginning(linked_list.head.right.right.right, 35)
linked_list.head.right.right.right = linked_list.insert_at_beginning(linked_list.head.right.right.right, 20)

# Flatten the list
linked_list.head = linked_list.flatten(linked_list.head)

linked_list.print_list()

Output:

Flattened linked list: [5, 7, 8, 30, 10, 19, 28, 22, 50]

Explanation -

In the above code, we create a Node class which represents a node in the linked list. Each node has a data attribute to store the value and two pointers: right and down. The right pointer is used to connect nodes horizontally, and the down pointer is used to connect nodes vertically.

The code also defines a LinkedList class, which has methods to insert nodes at the beginning of the list, print the list, and flatten the list.

In the LinkedList class, the insert_at_beginning() method takes a reference to the head node (head_ref) and data as input. It creates a new node with the given data and sets its down pointer to the current head. Then, it updates the head_ref to point to the new node, effectively inserting the new node at the beginning of the list. The updated head_ref is returned.

The print_list() method traverses the linked list and prints the data of each node, moving vertically using the down pointer until the end of the list is reached.

The merge_lists() method is a recursive function that takes two lists (a and b) as input and merges them into a single sorted list.

It compares the data of the nodes at the head of each list and recursively merges the remaining lists.

The merging is done by updating the down pointer of the current node to the result of the recursive call with the remaining nodes. The right pointer of the current node is set to None to ensure a flattened structure.

The flatten() method is the main function that flattens the given multilevel linked list. It takes the root node as input and recursively flattens the list by following these steps:

If the root is None or there are no nodes to the right (root.right is None), it returns the root.

It recursively calls flatten on the right sublist to flatten it.

Then, it merges the current root with the flattened right sublist using the merge_lists method.

Finally, it returns the flattened root. Then, an instance of the LinkedList class is created.

Nodes are inserted at the beginning of the list using the insert_at_beginning() method, creating a multilevel structure.

The list is flattened by calling the flatten method on the head of the linked list.

Finally, the flattened list is printed using the print_list method.

Next TopicWrite Python Program to find the Kth Smallest Element

← prev next →