Skip to content
Related Articles

Related Articles

Javascript Program For Flattening A Linked List

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 13 Jun, 2022

Given a linked list where every node represents a linked list and contains two pointers of its type: 

  1. Pointer to next node in the main list (we call it ‘right’ pointer in the code below).
  2. Pointer to a linked list where this node is headed (we call it the ‘down’ pointer in the code below).

All linked lists are sorted. See the following example  

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

Write a function flatten() to flatten the lists into a single linked list. The flattened linked list should also be sorted. For example, for the above input list, output list should be 5->7->8->10->19->20->22->28->30->35->40->45->50.

The idea is to use the Merge() process of merge sort for linked lists. We use merge() to merge lists one by one. We recursively merge() the current list with the already flattened list. 
The down pointer is used to link nodes of the flattened list.

Below is the implementation of the above approach:

Javascript




<script>
// Javascript program for flattening
// a Linked List
 
// Head of list
var head;
 
// Linked list Node
class Node
{
    constructor(val)
    {
        this.data = val;
        this.down = null;
        this.next = null;
    }
}
 
// An utility function to merge
// two sorted linked lists
function merge(a, b)
{
    // If first linked list is
    // empty then second is the
    // answer
    if (a == null)
    return b;
 
    // If second linked list is
    // empty then first is the
    // result
    if (b == null)
        return a;
 
    // Compare the data members of
    // the two linked lists and put
    // the larger one in the result
    var result;
 
    if (a.data < b.data)
    {
        result = a;
        result.down = merge(a.down, b);
    }
 
    else
    {
        result = b;
        result.down = merge(a, b.down);
    }
 
    result.right = null;
    return result;
}
 
function flatten(root)
{
    // Base Cases
    if (root == null ||
        root.right == null)
        return root;
 
    // Recur for list on right
    root.right = flatten(root.right);
 
    // Now merge
    root = merge(root, root.right);
 
    // Return the root
    // It will be in turn merged
    // with its left
    return root;
}
 
/* Utility function to insert a node
   at beginning of the linked list */
function push(head_ref, data)
{
    /* 1 & 2: Allocate the Node &
              Put in the data */
         var new_node = new Node(data);
 
    // 3. Make next of new Node as head
    new_node.down = head_ref;
 
    // 4. Move the head to point to
    // new Node
    head_ref = new_node;
 
    // 5. return to link it back
        return head_ref;
}
 
function printList()
{
    var temp = head;
    while (temp != null)
    {
        document.write(temp.data + " ");
        temp = temp.down;
    }
    document.write();
}
 
// Driver code
/* Create the following linked list
   5 -> 10 -> 19 -> 28 | | | | V V V
   V 7 20 22 35 | | | V V V 8 50 40
   | | V V 30 45 */
head = push(head, 30);
head = push(head, 8);
head = push(head, 7);
head = push(head, 5);
 
head.right = push(head.right, 20);
head.right = push(head.right, 10);
 
head.right.right =
push(head.right.right, 50);
head.right.right =
push(head.right.right, 22);
head.right.right =
push(head.right.right, 19);
 
head.right.right.right =
push(head.right.right.right, 45);
head.right.right.right =
push(head.right.right.right, 40);
head.right.right.right =
push(head.right.right.right, 35);
head.right.right.right =
push(head.right.right.right, 20);
 
// Flatten the list
head = flatten(head);
 
printList();
// This code is contributed by aashish1995
</script>


Output:

5 7 8 10 19 20 20 22 30 35 40 45 50

Time Complexity: O(N*N*M) – where N is the no of nodes in main linked list (reachable using right pointer) and M is the no of node in a single sub linked list (reachable using down pointer).
Space Complexity: O(N*M) as the recursive functions will use recursive stack of size equivalent to total number of elements in the lists.

Please refer complete article on Flattening a Linked List for more details!


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!