# Rearrange a given linked list in-place.

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

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

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 end and insert it as next
of current node.
b) Move current to next to next of current```

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

Better Solution
1) Copy contents of given linked list to a vector.
2) Rearrange given vector by swapping nodes from both ends.
3) Copy the modified vector back to 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 in two halves using found middle point in step 1.
3) Reverse the second half.
4) Do alternate merge of first and second halves. ```

Time Complexity of this solution is O(n).

Below is the implementation of this method.

## C++

```// C++ program to rearrange a linked list in-place
#include<bits/stdc++.h>
using namespace std;

struct Node
{
int data;
struct Node *next;
};

// Function to create newNode in a linkedlist
Node* newNode(int key)
{
Node *temp = new Node;
temp->data = key;
temp->next = NULL;
return temp;
}

// Function to reverse the linked list
{
// Initialize prev and current pointers
Node *prev = NULL, *curr = *head, *next;

while (curr)
{
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}

}

// Function to print the linked list
{
{
cout << head->data << " ";
}
cout << endl;
}

// Function to rearrange a linked list
{
// 1) Find the muddle point using tortoise and hare method
Node *slow = *head, *fast = slow->next;
while (fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
}

// 2) Split the linked list in two halves
slow->next = NULL;

// 3) Reverse the second half, i.e.,  4 -> 3

// 4) Merge alternate nodes
*head = newNode(0); // Assign dummy Node

// curr is the pointer to this dummy Node, which will
// be used to form the new list
{
// First add the element from list
{
curr = curr->next;
}

// Then add the element from second list
{
curr = curr->next;
}
}

}

// Driver program
int main()
{

return 0;
}
```

## Java

```// Java program to rearrange link list in place

/* 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
node = new Node(0); // Assign dummy Node

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

node = node.next;
}

public static void main(String[] args) {

list.rearrange(head); // rearrange list as per ques
System.out.println("");

}
}

// This code has been 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 above approach.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
3.3 Average Difficulty : 3.3/5.0
Based on 126 vote(s)