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

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

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.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 `

## 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 `

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 Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : andrew1234, Rajput-Ji