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

filter_none

edit
close

play_arrow

link
brightness_4
code

// A C++ program to demonstrate
// the printing of Linked List middle
// to left right order
  
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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