Javascript Program For Rearranging A Given Linked List In-Place

Given a singly linked list L₀ -> L₁ -> … -> L_n-1 -> L_n. Rearrange the nodes in the list so that the new formed list is : L₀ -> L_n -> L₁ -> L_n-1 -> L₂ -> L_n-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(n²) 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.

Javascript

<script>
// Javascript program to rearrange
// linked list in place

// Linked List Class

// Head of the list
var head;

// Node Class
class Node
{
    // Constructor to create
    // a new node
    constructor(d)
    {
        this.data = d;
        this.next = null;
    }
}

function printlist(node)
{
    if (node == null)
    {
        return;
    }
    while (node != null)
    {
        document.write(node.data +
                       " -> ");
        node = node.next;
    }
}

function reverselist(node)
{
    var prev = null,
        curr = node, next;
    while (curr != null)
    {
        next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
    }
    node = prev;
    return node;
}

function rearrange(node)
{
    // 1) Find the middle point using
    // tortoise and hare method
    var 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
    var node1 = node;
    var 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
    var 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;
}

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);

// Print original list
printlist(head);

// Rearrange list as per ques
rearrange(head);

document.write("<br/>");

// Print modified list
printlist(head);
// This code is contributed by gauravrajput1
</script>

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: 

Javascript

<script>
// Javascript code to rearrange linked list
// in place
class Node
{
    constructor()
    {
        this.data;
        this.next=null;
    }
}

// Function for rearranging a linked list
// with high and low value.
function rearrange(head)
{
    // Base case
    if (head == null)
        return null;

    // Two pointer variable.
    let prev = head, curr = head.next;

    while (curr != null)
    {
        // Swap function for swapping data.
        if (prev.data > curr.data)
        {
            let t = prev.data;
            prev.data = curr.data;
            curr.data = t;
        }

        // Swap function for swapping data
        if (curr.next != null &&
            curr.next.data > curr.data)
        {
            let 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 display Node
// of linked list.
function display(head)
{
    let curr = head;
    while (curr != null)
    {
        document.write(curr.data+" ");
        curr = curr.next;
    }
}

// Function to insert a Node in
// the linked list at the beginning.
function push(head,k)
{
    let tem = new Node();
    tem.data = k;
    tem.next = head;
    head = tem;
    return head;
}

// Driver code
let head = null;
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 unknown2108
</script>

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.

Javascript

<script>
// Javascript program to implement
// the above approach
// Creating the structure for node
class Node
{
    // Function to create newNode
    // in a linkedlist
    constructor(val)
    {
        this.data = val;
        this.next = null;
    }
}

var left = null;

// Function to print the list
function printlist(head)
{
    while (head != null)
    {
        document.write(head.data + " ");
        if (head.next != null)
        {
            document.write("->");
        }
        head = head.next;
    }
    document.write("<br/>");
}

// Function to rearrange
function rearrange(head)
{
    if (head != null)
    {
        left = head;
        reorderListUtil(left);
    }
}

function reorderListUtil(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)
    {
        var 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
var 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);

// Print original list
printlist(head);

// Modify the list
rearrange(head);

// Print modified list
printlist(head);
// This code is contributed by aashish1995
</script>

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), due to recursive call 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!