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:

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


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.