# Traverse Linked List from middle to left-right order using recursion

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

Given a Linked List. The task is to traverse the Linked List from middle to left-right order using recursion.
For Example:

If the given Linked List is: 2 -> 5 -> 8 -> 3 -> 7 -> 9 -> 12 -> NULL
The Middle to left-right order is : 3, 8, 7, 5, 9, 2, 12

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.

Explanation: Middle of the given linked list is ‘3’ so, we start traversing from middle by printing 3 then left and right of 3, so we print 8, 7 then print left of 8 and right of 7, so we print 5, 9 then print left of 5 and right of 9, so we print 2, 12.
Note: If number of node are even in a Linked List then print left right only. For this linked list( contains even number of nodes ) 2 -> 5 -> 8 -> 7 -> 9 -> 12 -> NULL.
The output should be 8, 7, 5, 9, 2, 12.
Examples:

Input: 20 -> 15 -> 23 -> 13 -> 19 -> 32 -> 16 -> 41 -> 11 -> NULL
Output: 19, 13, 32, 23, 16, 15, 41, 20, 11.
Input: 12 -> 25 -> 51 -> 16 -> 9 -> 90 -> 7 -> 2 -> NULL
Output: 16, 9, 51, 90, 25, 7, 12, 2.

Approach:
First, calculate the size of the linked list:

• If size is odd:
-> Then go to the (n+1)/2 -th node using recursion.
• If size is even:
-> Then go to the n/2 -th node using recursion.
• Now print node data and return next node address, do this procedure unless function call stack empty.

Below is the implementation of the above approach:

## C++

 `// A C++ program to demonstrate``// the printing of Linked List middle``// to left right order` `#include ``using` `namespace` `std;` `// A linked list node``class` `Node {``public``:``    ``int` `data;``    ``Node* next;``};` `// Given a reference (pointer to pointer)``// to the head of a list and an int, appends``// a new node at the end` `void` `append(Node** head_ref, ``int` `new_data)``{``    ``// Allocate node``    ``Node* new_node = ``new` `Node();` `    ``// Used in step 5``    ``Node* last = *head_ref;` `    ``// Put in the data``    ``new_node->data = new_data;` `    ``// This new node is going to be``    ``// the last node, so make next of``    ``// it as NULL``    ``new_node->next = NULL;` `    ``// If the Linked List is empty,``    ``// then make the new node as head``    ``if` `(*head_ref == NULL) {``        ``*head_ref = new_node;``        ``return``;``    ``}` `    ``// Else traverse till the last node``    ``while` `(last->next != NULL)``        ``last = last->next;` `    ``// Change the next of last node``    ``last->next = new_node;``    ``return``;``}` `// This function prints contents of``// linked list starting from head` `void` `printList(Node* node)``{``    ``while` `(node != NULL) {``        ``cout << ``" "` `<< node->data;` `        ``if` `(node->next != NULL)``            ``cout << ``"->"``;``        ``node = node->next;``    ``}``}` `// Function to get the size of linked list``int` `getSize(Node* head)``{``    ``if` `(head == NULL)``        ``return` `0;``    ``return` `1 + getSize(head->next);``}` `// Utility function to print the Linked List``// from middle to left right order``Node* printMiddleToLeftRightUtil(Node* head,``                                 ``int` `counter, ``int` `lSize)``{``    ``// Base Condition``    ``// When size of list is odd``    ``if` `(counter == 1 && lSize % 2 != 0) {` `        ``// Print node value``        ``cout << head->data;` `        ``// Returns address of next node``        ``return` `head->next;``    ``}` `    ``// Base Condition``    ``// When size of list is even``    ``else` `if` `(counter == 1) {` `        ``// Print node value``        ``// and next node value``        ``cout << head->data;``        ``cout << ``" , "` `<< head->next->data;` `        ``// Returns address of next to next node``        ``return` `head->next->next;``    ``}``    ``else` `{` `        ``// Recursive function call and``        ``// store return address``        ``Node* ptr = printMiddleToLeftRightUtil(``            ``head->next,``            ``counter - 1,``            ``lSize);` `        ``// Print head data``        ``cout << ``" , "` `<< head->data;` `        ``// Print ptr data``        ``cout << ``" , "` `<< ptr->data;` `        ``// Returns address of next node``        ``return` `ptr->next;``    ``}``}` `// Function to print Middle to``// Left-right order``void` `printMiddleToLeftRight(Node* head)``{``    ``// Function call to get the size``    ``// Of Linked List``    ``int` `listSize = getSize(head);` `    ``int` `middle = 0;` `    ``// Store middle when Linked``    ``// List size is odd``    ``if` `(listSize % 2 != 0) {``        ``middle = (listSize + 1) / 2;``    ``}` `    ``// Store middle when Linked``    ``// List size is even` `    ``else` `{``        ``middle = listSize / 2;``    ``}` `    ``// Utility function call print``    ``// Linked List from Middle``    ``// to left right order``    ``cout << ``"Output : "``;` `    ``printMiddleToLeftRightUtil(head,``                               ``middle,``                               ``listSize);``}` `// Driver code``int` `main()``{``    ``// Start with the empty list``    ``Node* head = NULL;` `    ``// Insert 6. So linked list``    ``// becomes 6->NULL``    ``append(&head, 6);` `    ``// Insert 6. So linked list``    ``// becomes 6->4->NULL``    ``append(&head, 4);``    ``append(&head, 8);``    ``append(&head, 7);``    ``append(&head, 9);``    ``append(&head, 11);``    ``append(&head, 2);` `    ``// After inserting linked list``    ``// becomes 6->4->8->7->9->11->2->NULL``    ``cout << ``"Created Linked list is: "``;` `    ``// Function to display Linked List content``    ``printList(head);``    ``cout << endl;` `    ``// Function call print Linked List from``    ``// Middle to left right order``    ``printMiddleToLeftRight(head);``    ``return` `0;``}`

## Java

 `// A Java program to demonstrate``// the printing of Linked List middle``// to left right order``class` `GFG``{` `// A linked list node``static` `class` `Node``{``    ``int` `data;``    ``Node next;``};` `// Given a reference (pointer to pointer)``// to the head of a list and an int, appends``// a new node at the end``static` `Node append(Node head_ref, ``int` `new_data)``{``    ``// Allocate node``    ``Node new_node = ``new` `Node();` `    ``// Used in step 5``    ``Node last = head_ref;` `    ``// Put in the data``    ``new_node.data = new_data;` `    ``// This new node is going to be``    ``// the last node, so make next of``    ``// it as null``    ``new_node.next = ``null``;` `    ``// If the Linked List is empty,``    ``// then make the new node as head``    ``if` `(head_ref == ``null``)``    ``{``        ``head_ref = new_node;``        ``return` `head_ref;``    ``}` `    ``// Else traverse till the last node``    ``while` `(last.next != ``null``)``        ``last = last.next;` `    ``// Change the next of last node``    ``last.next = new_node;``    ``return` `head_ref;``}` `// This function prints contents of``// linked list starting from head``static` `void` `printList(Node node)``{``    ``while` `(node != ``null``)``    ``{``        ``System.out.print( ``" "` `+ node.data);` `        ``if` `(node.next != ``null``)``            ``System.out.print(``"->"``);``        ``node = node.next;``    ``}``}` `// Function to get the size of linked list``static` `int` `getSize(Node head)``{``    ``if` `(head == ``null``)``        ``return` `0``;``    ``return` `1` `+ getSize(head.next);``}` `// Utility function to print the Linked List``// from middle to left right order``static` `Node printMiddleToLeftRightUtil(Node head,``                          ``int` `counter, ``int` `lSize)``{``    ``// Base Condition``    ``// When size of list is odd``    ``if` `(counter == ``1` `&& lSize % ``2` `!= ``0``)``    ``{` `        ``// Print node value``        ``System.out.print( head.data);` `        ``// Returns address of next node``        ``return` `head.next;``    ``}` `    ``// Base Condition``    ``// When size of list is even``    ``else` `if` `(counter == ``1``)``    ``{` `        ``// Print node value``        ``// and next node value``        ``System.out.print(head.data);``        ``System.out.print( ``" , "` `+ head.next.data);` `        ``// Returns address of next to next node``        ``return` `head.next.next;``    ``}``    ``else``    ``{` `        ``// Recursive function call and``        ``// store return address``        ``Node ptr = printMiddleToLeftRightUtil(head.next,``                                    ``counter - ``1``, lSize);` `        ``// Print head data``        ``System.out.print(``" , "` `+ head.data);` `        ``// Print ptr data``        ``System.out.print(``" , "` `+ ptr.data);` `        ``// Returns address of next node``        ``return` `ptr.next;``    ``}``}` `// Function to print Middle to``// Left-right order``static` `void` `printMiddleToLeftRight(Node head)``{``    ``// Function call to get the size``    ``// Of Linked List``    ``int` `listSize = getSize(head);` `    ``int` `middle = ``0``;` `    ``// Store middle when Linked``    ``// List size is odd``    ``if` `(listSize % ``2` `!= ``0``)``    ``{``        ``middle = (listSize + ``1``) / ``2``;``    ``}` `    ``// Store middle when Linked``    ``// List size is even``    ``else``    ``{``        ``middle = listSize / ``2``;``    ``}` `    ``// Utility function call print``    ``// Linked List from Middle``    ``// to left right order``    ``System.out.print(``"Output : "``);` `    ``printMiddleToLeftRightUtil(head, middle, listSize);``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ``// Start with the empty list``    ``Node head = ``null``;` `    ``// Insert 6. So linked list``    ``// becomes 6.null``    ``head = append(head, ``6``);` `    ``// Insert 6. So linked list``    ``// becomes 6.4.null``    ``head = append(head, ``4``);``    ``head = append(head, ``8``);``    ``head = append(head, ``7``);``    ``head = append(head, ``9``);``    ``head = append(head, ``11``);``    ``head = append(head, ``2``);` `    ``// After inserting linked list``    ``// becomes 6.4.8.7.9.11.2.null``    ``System.out.print(``"Created Linked list is: "``);` `    ``// Function to display Linked List content``    ``printList(head);``    ``System.out.println();` `    ``// Function call print Linked List from``    ``// Middle to left right order``    ``printMiddleToLeftRight(head);``}``}` `// This code is contributed by Arnab Kundu`

## Python3

 `# A Python3 program to demonstrate``# the printing of Linked List middle``# to left right order`` ` `# A linked list node``class` `Node:``    ` `    ``def` `__init__(``self``):``        ``self``.data ``=` `0``        ``self``.``next` `=` `None`` ` `# Given a reference (pointer to pointer)``# to the head of a list and an int, appends``# a new node at the end``def` `append(head_ref, new_data):` `    ``# Allocate node``    ``new_node ``=` `Node();`` ` `    ``# Used in step 5``    ``last ``=` `head_ref;`` ` `    ``# Put in the data``    ``new_node.data ``=` `new_data;`` ` `    ``# This new node is going to be``    ``# the last node, so make next of``    ``# it as None``    ``new_node.``next` `=` `None``;`` ` `    ``# If the Linked List is empty,``    ``# then make the new node as head``    ``if` `(head_ref ``=``=` `None``):``        ``head_ref ``=` `new_node;``        ``return` `head_ref;`` ` `    ``# Else traverse till the last node``    ``while` `(last.``next` `!``=` `None``):``        ``last ``=` `last.``next``;`` ` `    ``# Change the next of last node``    ``last.``next` `=` `new_node;``    ` `    ``return` `head_ref;``  ` `# This function prints contents of``# linked list starting from head``def` `printList(node):` `    ``while` `(node !``=` `None``):``        ``print``(``' '` `+` `str``(node.data), end ``=` `'')`` ` `        ``if` `(node.``next` `!``=` `None``):``            ``print``(``'->'``, end ``=` `'')``            ` `        ``node ``=` `node.``next``;``      ` `# Function to get the size of linked list``def` `getSize(head):` `    ``if` `(head ``=``=` `None``):``        ``return` `0``;``    ` `    ``return` `1` `+` `getSize(head.``next``);` `# Utility function to print the Linked List``# from middle to left right order``def` `printMiddleToLeftRightUtil(head, counter, lSize):` `    ``# Base Condition``    ``# When size of list is odd``    ``if` `(counter ``=``=` `1` `and` `lSize ``%` `2` `!``=` `0``):`` ` `        ``# Print node value``        ``print``(head.data, end ``=` `'')`` ` `        ``# Returns address of next node``        ``return` `head.``next``;``    ` `    ``# Base Condition``    ``# When size of list is even``    ``elif` `(counter ``=``=` `1``):`` ` `        ``# Print node value``        ``# and next node value``        ``print``(``str``(head.data) ``+` `' , '` `+` `str``(head.``next``.data), end ``=` `'')`` ` `        ``# Returns address of next to next node``        ``return` `head.``next``.``next``;``    ` `    ``else``:`` ` `        ``# Recursive function call and``        ``# store return address``        ``ptr ``=` `printMiddleToLeftRightUtil(head.``next``, counter ``-` `1``,lSize);`` ` `        ``# Print head data``        ``print``(``' , '` `+` `str``(head.data) ``+` `' , '` `+` `str``(ptr.data), end ``=` `'')`` ` `        ``# Returns address of next node``        ``return` `ptr.``next``;``     ` `# Function to print Middle to``# Left-right order``def` `printMiddleToLeftRight(head):` `    ``# Function call to get the size``    ``# Of Linked List``    ``listSize ``=` `getSize(head);`` ` `    ``middle ``=` `0``;`` ` `    ``# Store middle when Linked``    ``# List size is odd``    ``if` `(listSize ``%` `2` `!``=` `0``):``        ``middle ``=` `(listSize ``+` `1``) ``/``/` `2``;`` ` `    ``# Store middle when Linked``    ``# List size is even``    ``else``:``        ``middle ``=` `listSize ``/``/` `2``;``     ` `    ``# Utility function call print``    ``# Linked List from Middle``    ``# to left right order``    ``print``(``'Output :'``, end ``=` `' '``)`` ` `    ``printMiddleToLeftRightUtil(head, middle, listSize);`` ` `# Driver code``if` `__name__``=``=``'__main__'``:``    ` `    ``# Start with the empty list``    ``head ``=` `None``;`` ` `    ``# Insert 6. So linked list``    ``# becomes 6.None``    ``head ``=` `append(head, ``6``);`` ` `    ``# Insert 6. So linked list``    ``# becomes 6.4.None``    ``head ``=` `append(head, ``4``);``    ``head ``=` `append(head, ``8``);``    ``head ``=` `append(head, ``7``);``    ``head ``=` `append(head, ``9``)``    ``head ``=` `append(head, ``11``);``    ``head ``=` `append(head, ``2``)``    ` `    ``# After inserting linked list``    ``# becomes 6.4.8.7.9.11.2.None``    ``print``(``"Created Linked list is:"``, end ``=` `' '``)`` ` `    ``# Function to display Linked List content``    ``printList(head);``    ``print``()`` ` `    ``# Function call print Linked List from``    ``# Middle to left right order``    ``printMiddleToLeftRight(head);` `    ``# This code is contributed by rutvik_56`

## C#

 `// A C# program to demonstrate``// the printing of Linked List middle``// to left right order``using` `System;` `public` `class` `GFG``{`` ` `// A linked list node``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node next;``};`` ` `// Given a reference (pointer to pointer)``// to the head of a list and an int, appends``// a new node at the end``static` `Node append(Node head_ref, ``int` `new_data)``{``    ``// Allocate node``    ``Node new_node = ``new` `Node();`` ` `    ``// Used in step 5``    ``Node last = head_ref;`` ` `    ``// Put in the data``    ``new_node.data = new_data;`` ` `    ``// This new node is going to be``    ``// the last node, so make next of``    ``// it as null``    ``new_node.next = ``null``;`` ` `    ``// If the Linked List is empty,``    ``// then make the new node as head``    ``if` `(head_ref == ``null``)``    ``{``        ``head_ref = new_node;``        ``return` `head_ref;``    ``}`` ` `    ``// Else traverse till the last node``    ``while` `(last.next != ``null``)``        ``last = last.next;`` ` `    ``// Change the next of last node``    ``last.next = new_node;``    ``return` `head_ref;``}`` ` `// This function prints contents of``// linked list starting from head``static` `void` `printList(Node node)``{``    ``while` `(node != ``null``)``    ``{``        ``Console.Write( ``" "` `+ node.data);`` ` `        ``if` `(node.next != ``null``)``            ``Console.Write(``"->"``);``        ``node = node.next;``    ``}``}`` ` `// Function to get the size of linked list``static` `int` `getSize(Node head)``{``    ``if` `(head == ``null``)``        ``return` `0;``    ``return` `1 + getSize(head.next);``}`` ` `// Utility function to print the Linked List``// from middle to left right order``static` `Node printMiddleToLeftRightUtil(Node head,``                          ``int` `counter, ``int` `lSize)``{``    ``// Base Condition``    ``// When size of list is odd``    ``if` `(counter == 1 && lSize % 2 != 0)``    ``{`` ` `        ``// Print node value``        ``Console.Write( head.data);`` ` `        ``// Returns address of next node``        ``return` `head.next;``    ``}`` ` `    ``// Base Condition``    ``// When size of list is even``    ``else` `if` `(counter == 1)``    ``{`` ` `        ``// Print node value``        ``// and next node value``        ``Console.Write(head.data);``        ``Console.Write( ``" , "` `+ head.next.data);`` ` `        ``// Returns address of next to next node``        ``return` `head.next.next;``    ``}``    ``else``    ``{`` ` `        ``// Recursive function call and``        ``// store return address``        ``Node ptr = printMiddleToLeftRightUtil(head.next,``                                    ``counter - 1, lSize);`` ` `        ``// Print head data``        ``Console.Write(``" , "` `+ head.data);`` ` `        ``// Print ptr data``        ``Console.Write(``" , "` `+ ptr.data);`` ` `        ``// Returns address of next node``        ``return` `ptr.next;``    ``}``}`` ` `// Function to print Middle to``// Left-right order``static` `void` `printMiddleToLeftRight(Node head)``{``    ``// Function call to get the size``    ``// Of Linked List``    ``int` `listSize = getSize(head);`` ` `    ``int` `middle = 0;`` ` `    ``// Store middle when Linked``    ``// List size is odd``    ``if` `(listSize % 2 != 0)``    ``{``        ``middle = (listSize + 1) / 2;``    ``}`` ` `    ``// Store middle when Linked``    ``// List size is even``    ``else``    ``{``        ``middle = listSize / 2;``    ``}`` ` `    ``// Utility function call print``    ``// Linked List from Middle``    ``// to left right order``    ``Console.Write(``"Output : "``);`` ` `    ``printMiddleToLeftRightUtil(head, middle, listSize);``}`` ` `// Driver code``public` `static` `void` `Main(String []args)``{``    ``// Start with the empty list``    ``Node head = ``null``;`` ` `    ``// Insert 6. So linked list``    ``// becomes 6.null``    ``head = append(head, 6);`` ` `    ``// Insert 6. So linked list``    ``// becomes 6.4.null``    ``head = append(head, 4);``    ``head = append(head, 8);``    ``head = append(head, 7);``    ``head = append(head, 9);``    ``head = append(head, 11);``    ``head = append(head, 2);`` ` `    ``// After inserting linked list``    ``// becomes 6.4.8.7.9.11.2.null``    ``Console.Write(``"Created Linked list is: "``);`` ` `    ``// Function to display Linked List content``    ``printList(head);``    ``Console.WriteLine();`` ` `    ``// Function call print Linked List from``    ``// Middle to left right order``    ``printMiddleToLeftRight(head);``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``
Output:
```Created Linked list is:  6-> 4-> 8-> 7-> 9-> 11-> 2
Output : 7 , 8 , 9 , 4 , 11 , 6 , 2```

My Personal Notes arrow_drop_up