# Java Program For Flattening A Linked List

• Last Updated : 21 Dec, 2021

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:

## Java

 `// Java program for flattening ``// a Linked List``class` `LinkedList``{``    ``// Head of list``    ``Node head;  `` ` `    ``// Linked list Node``    ``class` `Node``    ``{``        ``int` `data;``        ``Node right, down;``        ``Node(``int` `data)``        ``{``            ``this``.data = data;``            ``right = ``null``;``            ``down = ``null``;``        ``}``    ``}`` ` `    ``// An utility function to merge ``    ``// two sorted linked lists``    ``Node merge(Node a, Node 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``        ``Node 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;``    ``}`` ` `    ``Node flatten(Node 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 */``    ``Node push(Node head_ref, ``int` `data)``    ``{``        ``/* 1 & 2: Allocate the Node &``                  ``Put in the data */``        ``Node 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;``    ``}`` ` `    ``void` `printList()``    ``{``        ``Node temp = head;``        ``while` `(temp != ``null``)``        ``{``            ``System.out.print(temp.data + ``" "``);``            ``temp = temp.down;``        ``}``        ``System.out.println();``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``LinkedList L = ``new` `LinkedList();`` ` `        ``/* 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 */``        ``L.head = L.push(L.head, ``30``);``        ``L.head = L.push(L.head, ``8``);``        ``L.head = L.push(L.head, ``7``);``        ``L.head = L.push(L.head, ``5``);`` ` `        ``L.head.right = ``        ``L.push(L.head.right, ``20``);``        ``L.head.right = ``        ``L.push(L.head.right, ``10``);`` ` `        ``L.head.right.right = ``        ``L.push(L.head.right.right, ``50``);``        ``L.head.right.right = ``        ``L.push(L.head.right.right, ``22``);``        ``L.head.right.right = ``        ``L.push(L.head.right.right, ``19``);`` ` `        ``L.head.right.right.right = ``        ``L.push(L.head.right.right.right, ``45``);``        ``L.head.right.right.right = ``        ``L.push(L.head.right.right.right, ``40``);``        ``L.head.right.right.right = ``        ``L.push(L.head.right.right.right, ``35``);``        ``L.head.right.right.right = ``        ``L.push(L.head.right.right.right, ``20``);`` ` `        ``// Flatten the list``        ``L.head = L.flatten(L.head);`` ` `        ``L.printList();``    ``}``} ``// This code is contributed by Rajat Mishra `

Output:

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

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

My Personal Notes arrow_drop_up