Related Articles

# Program to unfold a folded linked list

• Difficulty Level : Hard
• Last Updated : 07 Jun, 2021

A linked list L0 -> L1 -> L2 -> ….. -> LN can be folded as L0 -> LN -> L1 -> LN – 1 -> L2 -> …..

Examples:

Input: 1 -> 6 -> 2 -> 5 -> 3 -> 4
Output: 1 2 3 4 5 6

Input: 1 -> 5 -> 2 -> 4 -> 3
Output: 1 2 3 4 5

Approach: Make a recursive call and store the next node in temp pointer, first node will act as head node and the node which is stored in temp pointer will act as a tail of the list. On returning after reaching the base condition link the head and tail to previous head and tail respectively.

Base condition: If number of nodes is even then the second last node is head and the last node is tail and if the number of nodes is odd then last node will act as head as well as tail.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include``using` `namespace` `std;` `// Node Class``struct` `Node``{``    ``int` `data;``    ``Node *next;``};` `// Head of the list``Node *head;` `// Tail of the list``Node *tail;` `// Function to print the list``void` `display()``{``    ``if` `(head == NULL)``        ``return``;``        ` `    ``Node* temp = head;` `    ``while` `(temp != NULL)``    ``{``        ``cout << temp->data << ``" "``;``        ``temp = temp->next;``    ``}``    ``cout << endl;``}` `// Funcion to add node in the list``void` `push(``int` `data)``{``    ` `    ``// Create new node``    ``Node* nn = ``new` `Node();``    ``nn->data = data;``    ``nn->next = NULL;` `    ``// Linking at first position``    ``if` `(head == NULL)``    ``{``        ``head = nn;``    ``}``    ``else``    ``{``        ``Node* temp = head;` `        ``while` `(temp->next != NULL)``        ``{``            ``temp = temp->next;``        ``}` `        ``// Linking at last in list``        ``temp->next = nn;``    ``}``}` `// Function to unfold the given link list``void` `unfold(Node* node)``{``    ``if` `(node == NULL)``        ``return``;` `    ``// This condition will reach if``    ``// the number of nodes is odd``    ``// head and tail is same i->e-> last node``    ``if` `(node->next == NULL)``    ``{``        ``head = tail = node;``        ``return``;``    ``}` `    ``// This base condition will reach if``    ``// the number of nodes is even``    ``// mark head to the second last node``    ``// and tail to the last node``    ``else` `if` `(node->next->next == NULL)``    ``{``        ``head = node;``        ``tail = node->next;``        ``return``;``    ``}` `    ``// Storing next node in temp pointer``    ``// before making the recursive call``    ``Node* temp = node->next;` `    ``// Recursive call``    ``unfold(node->next->next);` `    ``// Connecting first node to head``    ``// and mark it as a new head``    ``node->next = head;``    ``head = node;` `    ``// Connecting tail to second node (temp)``    ``// and mark it as a new tail``    ``tail->next = temp;``    ``tail = temp;``    ``tail->next = NULL;``}` `// Driver code``int` `main()``{``    ` `    ``// Adding nodes to the list``    ``push(1);``    ``push(5);``    ``push(2);``    ``push(4);``    ``push(3);` `    ``// Displaying the original nodes``    ``display();` `    ``// Calling unfold function``    ``unfold(head);` `    ``// Displaying the list``    ``// after modification``    ``display();``}` `// This code is contributed by pratham76`

## Java

 `// Java implementation of the approach``public` `class` `GFG {` `    ``// Node Class``    ``private` `class` `Node {``        ``int` `data;``        ``Node next;``    ``}` `    ``// Head of the list``    ``private` `Node head;` `    ``// Tail of the list``    ``private` `Node tail;` `    ``// Function to print the list``    ``public` `void` `display()``    ``{` `        ``if` `(head == ``null``)``            ``return``;``        ``Node temp = head;` `        ``while` `(temp != ``null``) {``            ``System.out.print(temp.data + ``" "``);``            ``temp = temp.next;``        ``}``        ``System.out.println();``    ``}` `    ``// Funcion to add node in the list``    ``public` `void` `push(``int` `data)``    ``{` `        ``// Create new node``        ``Node nn = ``new` `Node();``        ``nn.data = data;``        ``nn.next = ``null``;` `        ``// Linking at first position``        ``if` `(head == ``null``) {``            ``head = nn;``        ``}``        ``else` `{``            ``Node temp = head;` `            ``while` `(temp.next != ``null``) {``                ``temp = temp.next;``            ``}` `            ``// Linking at last in list``            ``temp.next = nn;``        ``}``    ``}` `    ``// Function to unfold the given link list``    ``private` `void` `unfold(Node node)``    ``{``        ``if` `(node == ``null``)``            ``return``;` `        ``// This condition will reach if``        ``// the number of nodes is odd``        ``// head and tail is same i.e. last node``        ``if` `(node.next == ``null``) {``            ``head = tail = node;``            ``return``;``        ``}` `        ``// This base condition will reach if``        ``// the number of nodes is even``        ``// mark head to the second last node``        ``// and tail to the last node``        ``else` `if` `(node.next.next == ``null``) {``            ``head = node;``            ``tail = node.next;``            ``return``;``        ``}` `        ``// Storing next node in temp pointer``        ``// before making the recursive call``        ``Node temp = node.next;` `        ``// Recursive call``        ``unfold(node.next.next);` `        ``// Connecting first node to head``        ``// and mark it as a new head``        ``node.next = head;``        ``head = node;` `        ``// Connecting tail to second node (temp)``        ``// and mark it as a new tail``        ``tail.next = temp;``        ``tail = temp;``        ``tail.next = ``null``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``GFG l = ``new` `GFG();` `        ``// Adding nodes to the list``        ``l.push(``1``);``        ``l.push(``5``);``        ``l.push(``2``);``        ``l.push(``4``);``        ``l.push(``3``);` `        ``// Displaying the original nodes``        ``l.display();` `        ``// Calling unfold function``        ``l.unfold(l.head);` `        ``// Displaying the list``        ``// after modification``        ``l.display();``    ``}``}`

## Python3

 `# Python3 implementation of the approach` `# Node Class``class` `Node:``    ` `    ``def` `__init__(``self``, data):``        ` `        ``self``.data ``=` `data``        ``self``.``next` `=` `None` `# Head of the list``head ``=` `None` `# Tail of the list``tail ``=` `None` `# Function to print the list``def` `display():``    ` `    ``if` `(head ``=``=` `None``):``        ``return``    ` `    ``temp ``=` `head` `    ``while` `(temp !``=` `None``):``        ``print``(temp.data, end ``=` `" "``)``        ``temp ``=` `temp.``next``    ` `    ``print``()` `# Function to add node in the list``def` `push(data):``    ` `    ``global` `head, tail``    ` `    ``# Create new node``    ``nn ``=` `Node(data)` `    ``# Linking at first positio``    ``if` `(head ``=``=` `None``):``        ``head ``=` `nn``    ``else``:``        ``temp ``=` `head` `        ``while` `(temp.``next` `!``=` `None``):``            ``temp ``=` `temp.``next``            ` `        ``# Linking at last in list``        ``temp.``next` `=` `nn` `# Function to unfold the given link list``def` `unfold(node):``    ` `    ``global` `head, tail``    ` `    ``if` `(node ``=``=` `None``):``        ``return` `    ``# This condition will reach if``    ``# the number of nodes is odd``    ``# head and tail is same i.e. last node``    ``if` `(node.``next` `=``=` `None``):``        ``head ``=` `tail ``=` `node``        ``return``    ` `    ``# This base condition will reach if``    ``# the number of nodes is even``    ``# mark head to the second last node``    ``# and tail to the last node``    ``elif` `(node.``next``.``next` `=``=` `None``):``        ``head ``=` `node``        ``tail ``=` `node.``next``        ``return``    ` `    ``# Storing next node in temp pointer``    ``# before making the recursive call``    ``temp ``=` `node.``next` `    ``# Recursive call``    ``unfold(node.``next``.``next``)` `    ``# Connecting first node to head``    ``# and mark it as a new head``    ``node.``next` `=` `head``    ``head ``=` `node` `    ``# Connecting tail to second node (temp)``    ``# and mark it as a new tail``    ``tail.``next` `=` `temp``    ``tail ``=` `temp``    ``tail.``next` `=` `None` `# Driver code``if` `__name__``=``=``'__main__'``:` `    ``# Adding nodes to the list``    ``push(``1``)``    ``push(``5``)``    ``push(``2``)``    ``push(``4``)``    ``push(``3``)` `    ``# Displaying the original nodes``    ``display()` `    ``# Calling unfold function``    ``unfold(head)` `    ``# Displaying the list``    ``# after modification``    ``display()` `# This code is contributed by rutvik_56`

## C#

 `// C# implementation of the approach``using` `System;``public` `class` `GFG {` `    ``// Node Class``    ``private` `class` `Node {``        ``public` `int` `data;``        ``public` `Node next;``    ``}` `    ``// Head of the list``    ``private` `Node head;` `    ``// Tail of the list``    ``private` `Node tail;` `    ``// Function to print the list``    ``public` `void` `display()``    ``{` `        ``if` `(head == ``null``)``            ``return``;``        ``Node temp = head;` `        ``while` `(temp != ``null``) {``            ``Console.Write(temp.data + ``" "``);``            ``temp = temp.next;``        ``}``        ``Console.WriteLine();``    ``}` `    ``// Funcion to add node in the list``    ``public` `void` `push(``int` `data)``    ``{` `        ``// Create new node``        ``Node nn = ``new` `Node();``        ``nn.data = data;``        ``nn.next = ``null``;` `        ``// Linking at first position``        ``if` `(head == ``null``) {``            ``head = nn;``        ``}``        ``else` `{``            ``Node temp = head;` `            ``while` `(temp.next != ``null``) {``                ``temp = temp.next;``            ``}` `            ``// Linking at last in list``            ``temp.next = nn;``        ``}``    ``}` `    ``// Function to unfold the given link list``    ``private` `void` `unfold(Node node)``    ``{``        ``if` `(node == ``null``)``            ``return``;` `        ``// This condition will reach if``        ``// the number of nodes is odd``        ``// head and tail is same i.e. last node``        ``if` `(node.next == ``null``) {``            ``head = tail = node;``            ``return``;``        ``}` `        ``// This base condition will reach if``        ``// the number of nodes is even``        ``// mark head to the second last node``        ``// and tail to the last node``        ``else` `if` `(node.next.next == ``null``) {``            ``head = node;``            ``tail = node.next;``            ``return``;``        ``}` `        ``// Storing next node in temp pointer``        ``// before making the recursive call``        ``Node temp = node.next;` `        ``// Recursive call``        ``unfold(node.next.next);` `        ``// Connecting first node to head``        ``// and mark it as a new head``        ``node.next = head;``        ``head = node;` `        ``// Connecting tail to second node (temp)``        ``// and mark it as a new tail``        ``tail.next = temp;``        ``tail = temp;``        ``tail.next = ``null``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{` `        ``GFG l = ``new` `GFG();` `        ``// Adding nodes to the list``        ``l.push(1);``        ``l.push(5);``        ``l.push(2);``        ``l.push(4);``        ``l.push(3);` `        ``// Displaying the original nodes``        ``l.display();` `        ``// Calling unfold function``        ``l.unfold(l.head);` `        ``// Displaying the list``        ``// after modification``        ``l.display();``    ``}``}``/* This code contributed by PrinciRaj1992 */`

## Javascript

 ``
Output:
```1 5 2 4 3
1 2 3 4 5```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up