Skip to content
Related Articles

Related Articles

Java Program For Rearranging A Given Linked List In-Place.

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 15 Jun, 2022

Given a singly linked list L0 -> L1 -> … -> Ln-1 -> Ln. Rearrange the nodes in the list so that the new formed list is : L0 -> Ln -> L1 -> Ln-1 -> L2 -> Ln-2
You are required to do this in place without altering the nodes’ values. 

Examples: 

Input: 1 -> 2 -> 3 -> 4
Output: 1 -> 4 -> 2 -> 3

Input: 1 -> 2 -> 3 -> 4 -> 5
Output: 1 -> 5 -> 2 -> 4 -> 3

Simple Solution:

1) Initialize current node as head.
2) While next of current node is not null, do following
    a) Find the last node, remove it from the end and insert it as next
       of the current node.
    b) Move current to next to next of current

The time complexity of the above simple solution is O(n2) where n is the number of nodes in the linked list.

Better Solution: 
1) Copy contents of the given linked list to a vector. 
2) Rearrange the given vector by swapping nodes from both ends. 
3) Copy the modified vector back to the linked list. 
Implementation of this approach: https://ide.geeksforgeeks.org/1eGSEy 
Thanks to Arushi Dhamija for suggesting this approach.

Efficient Solution:

1) Find the middle point using tortoise and hare method.
2) Split the linked list into two halves using found middle point in step 1.
3) Reverse the second half.
4) Do alternate merge of first and second halves.

The Time Complexity of this solution is O(n). 

Below is the implementation of this method.

Java




// Java program to rearrange linked list
// in place
 
// Linked List Class
class LinkedList
{
    // head of the list
    static Node head;
 
    // Node Class
    static class Node
    {
        int data;
        Node next;
 
        // Constructor to create
        // a new node
        Node(int d)
        {
            data = d;
            next = null;
        }
    }
 
    void printlist(Node node)
    {
        if (node == null)
        {
            return;
        }
        while (node != null)
        {
            System.out.print(node.data +
                             " -> ");
            node = node.next;
        }
    }
 
    Node reverselist(Node node)
    {
        Node prev = null,
             curr = node, next;
        while (curr != null)
        {
            next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        node = prev;
        return node;
    }
 
    void rearrange(Node node)
    {
        // 1) Find the middle point using
        // tortoise and hare method
        Node slow = node, fast = slow.next;
        while (fast != null &&
               fast.next != null)
        {
            slow = slow.next;
            fast = fast.next.next;
        }
 
        // 2) Split the linked list in
        // two halves
        // node1, head of first half-
        // 1 -> 2 -> 3
        // node2, head of second half-
        // 4 -> 5
        Node node1 = node;
        Node node2 = slow.next;
        slow.next = null;
 
        // 3) Reverse the second half,
        // i.e., 5 -> 4
        node2 = reverselist(node2);
 
        // 4) Merge alternate nodes
        // Assign dummy Node
        node = new Node(0);
 
        // curr is the pointer to this
        // dummy Node, which will be
        // used to form the new list
        Node curr = node;
        while (node1 != null ||
               node2 != null)
        {
            // First add the element
            // from first list
            if (node1 != null)
            {
                curr.next = node1;
                curr = curr.next;
                node1 = node1.next;
            }
 
            // Then add the element from
            // second list
            if (node2 != null)
            {
                curr.next = node2;
                curr = curr.next;
                node2 = node2.next;
            }
        }
 
        // Assign the head of the new
        // list to head pointer
        node = node.next;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        LinkedList list = new LinkedList();
        list.head = new Node(1);
        list.head.next = new Node(2);
        list.head.next.next =
        new Node(3);
        list.head.next.next.next =
        new Node(4);
        list.head.next.next.next.next =
        new Node(5);
  
        // Print original list
        list.printlist(head);
 
        // Rearrange list as per ques
        list.rearrange(head);
        System.out.println("");
 
        // Print modified list
        list.printlist(head);
    }
}
// This code is contributed by Mayank Jaiswal


Output:

1 -> 2 -> 3 -> 4 -> 5 
1 -> 5 -> 2 -> 4 -> 3

Time Complexity: O(n) 
Auxiliary Space: O(1)
Thanks to Gaurav Ahirwar for suggesting the above approach.

Another approach: 
1. Take two pointers prev and curr, which hold the addresses of head and head-> next. 
2. Compare their data and swap. 
After that, a new linked list is formed. 

Below is the implementation: 

Java




// Java code to rearrange linked list
// in place
class Geeks
{
    static class Node
    {
        int data;
        Node next;
    }
 
    // Function for rearranging a
    // linked list with high and
    // low value.
    static Node rearrange(Node head)
    {
        // Base case
        if (head == null)
            return null;
 
        // Two pointer variable.
        Node prev = head,
             curr = head.next;
 
        while (curr != null)
        {
            // Swap function for swapping
            // data.
            if (prev.data > curr.data)
            {
                int t = prev.data;
                prev.data = curr.data;
                curr.data = t;
            }
 
            // Swap function for swapping data.
            if (curr.next != null &&
                curr.next.data > curr.data)
            {
                int t = curr.next.data;
                curr.next.data = curr.data;
                curr.data = t;
            }
 
            prev = curr.next;
 
            if (curr.next == null)
                break;
            curr = curr.next.next;
        }
        return head;
    }
 
    // Function to insert a Node in
    // the linked list at the beginning.
    static Node push(Node head, int k)
    {
        Node tem = new Node();
        tem.data = k;
        tem.next = head;
        head = tem;
        return head;
    }
 
    // Function to display Node of
    // linked list.
    static void display(Node head)
    {
        Node curr = head;
        while (curr != null)
        {
            System.out.printf("%d ",
                              curr.data);
            curr = curr.next;
        }
    }
 
    // Driver code
    public static void main(String args[])
    {
        Node head = null;
 
        // Let create a linked list.
        // 9 . 6 . 8 . 3 . 7
        head = push(head, 7);
        head = push(head, 3);
        head = push(head, 8);
        head = push(head, 6);
        head = push(head, 9);
        head = rearrange(head);
        display(head);
    }
}
// This code is contributed by Arnab Kundu


Output:

6 9 3 8 7

Time Complexity : O(n) 
Auxiliary Space : O(1) 
Thanks to Aditya for suggesting this approach.

Another Approach: (Using recursion)  

  1. Hold a pointer to the head node and go till the last node using recursion
  2. Once the last node is reached, start swapping the last node to the next of head node
  3. Move the head pointer to the next node
  4. Repeat this until the head and the last node meet or come adjacent to each other
  5. Once the Stop condition met, we need to discard the left nodes to fix the loop created in the list while swapping nodes.

Java




// Java implementation
import java.io.*;
// Java program to implement
// the above approach
// Creating the structure
// for node
class Node
{
    int data;
    Node next;
 
    // Function to create newNode
    // in a linkedlist
    Node(int key)
    {
        data = key;
        next = null;
    }
}
class GFG
{
    Node left = null;
 
    // Function to print the list
    void printlist(Node head)
    {
        while (head != null)
        {
            System.out.print(head.data +
                             " ");
            if (head.next != null)
            {
                System.out.print("->");
            }
            head = head.next;
        }
        System.out.println();
    }
 
    // Function to rearrange
    void rearrange(Node head)
    {
        if (head != null)
        {
            left = head;
            reorderListUtil(left);
        }
    }
 
    void reorderListUtil(Node right)
    {
        if (right == null)
        {
            return;
        }
 
        reorderListUtil(right.next);
 
        // We set left = null, when we
        // reach stop condition, so no
        // processing required after that
        if (left == null)
        {
            return;
        }
 
        // Stop condition: odd case :
        // left = right, even
        // case : left.next = right
        if (left != right &&
            left.next != right)
        {
            Node temp = left.next;
            left.next = right;
            right.next = temp;
            left = temp;
        }
        else
        {
            // stop condition , set null
            // to left nodes
            if (left.next == right)
            {
                // even case
                left.next.next = null;
                left = null;
            }
            else
            {
                // odd case
                left.next = null;
                left = null;
            }
        }
    }
 
    // Drivers Code
    public static void main(String[] args)
    {
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next =
        new Node(4);
        head.next.next.next.next =
        new Node(5);
       
        GFG gfg = new GFG();
 
        // Print original list
        gfg.printlist(head);       
 
        // Modify the list
        gfg.rearrange(head);
 
        // Print modified list
        gfg.printlist(head);
    }
}
// This code is contributed by Vishal Singh


Output:

1 ->2 ->3 ->4 ->5 
1 ->5 ->2 ->4 ->3

Time Complexity: O(n), where n represents the length of the given linked list.
Auxiliary Space: O(n), for recursive stack where n represents the length of the given linked list.

Please refer complete article on Rearrange a given linked list in-place. for more details!


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!