 GeeksforGeeks App
Open App Browser
Continue

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

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

Time complexity: O(N) where N is the size of the given linked list

Auxiliary space: O(N) for call stack

My Personal Notes arrow_drop_up