Open In App

Javascript Program For Reversing Alternate K Nodes In A Singly Linked List

Last Updated : 21 Aug, 2022
Improve
Improve
Like Article
Like
Save
Share
Report

Given a linked list, write a function to reverse every alternate k nodes (where k is an input to the function) in an efficient way. Give the complexity of your algorithm.

Example: 

Inputs:   1->2->3->4->5->6->7->8->9->NULL and k = 3
Output:   3->2->1->4->5->6->9->8->7->NULL. 

Method 1 (Process 2k nodes and recursively call for rest of the list): 
This method is basically an extension of the method discussed in this post. 

kAltReverse(struct node *head, int k)
  1)  Reverse first k nodes.
  2)  In the modified list head points to the kth node.  So change next 
       of head to (k+1)th node
  3)  Move the current pointer to skip next k nodes.
  4)  Call the kAltReverse() recursively for rest of the n - 2k nodes.
  5)  Return new head of the list.

Javascript




<script>
// JavaScript program to reverse
// alternate k nodes in a linked list
class Node
{
    constructor(d)
    {
        this.data = d;
        this.next = null;
    }
}
 
let head;
 
// Reverses alternate k nodes and returns
// the pointer to the new head node
function kAltReverse(node, k)
{
    let current = node;
    let next = null, prev = null;
    let count = 0;
 
    /* 1) reverse first k nodes of the
          linked list */
    while (current != null && count < k)
    {
        next = current.next;
        current.next = prev;
        prev = current;
        current = next;
        count++;
    }
 
    /* 2) Now head points to the kth node. 
          So change next of head to
          (k+1)th node*/
    if (node != null)
    {
        node.next = current;
    }
 
    /* 3) We do not want to reverse next k
          nodes. So move the current pointer
          to skip next k nodes */
    count = 0;
    while (count < k - 1 &&
           current != null)
    {
        current = current.next;
        count++;
    }
 
    /* 4) Recursively call for the list starting
          from current->next. And make rest of
          the list as next of first node */
    if (current != null)
    {
        current.next =
                kAltReverse(current.next, k);
    }
 
    /* 5) prev is new head of the
          input list */
    return prev;
}
 
function printList(node)
{
    while (node != null)
    {
        document.write(node.data + " ");
        node = node.next;
    }
}
 
function push(newdata)
{
    let mynode = new Node(newdata);
    mynode.next = head;
    head = mynode;
}
 
// Driver code
 
// Creating the linkedlist
for(let i = 20; i > 0; i--)
{
    push(i);
}
document.write("Given Linked List :<br>");
printList(head);
head = kAltReverse(head, 3);
 
document.write("<br>");
document.write("Modified Linked List :<br>");
printList(head);
// This code is contributed by rag2127
</script>


Output: 

Given linked list
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Modified Linked list
3 2 1 4 5 6 9 8 7 10 11 12 15 14 13 16 17 18 20 19

Time Complexity: O(n)

Method 2 (Process k nodes and recursively call for rest of the list): 
The method 1 reverses the first k node and then moves the pointer to k nodes ahead. So method 1 uses two while loops and processes 2k nodes in one recursive call. 

This method processes only k nodes in a recursive call. It uses a third bool parameter b which decides whether to reverse the k elements or simply move the pointer.  

_kAltReverse(struct node *head, int k, bool b)
  1)  If b is true, then reverse first k nodes.
  2)  If b is false, then move the pointer k nodes ahead.
  3)  Call the kAltReverse() recursively for rest of the n - k nodes and link 
       rest of the modified list with end of first k nodes. 
  4)  Return new head of the list.

Javascript




<script>
// Javascript program to reverse
// alternate k nodes in a linked list
var head;
 
class Node
{
    constructor(val)
    {
        this.data = val;
        this.next = null;
    }
}
      
/* Alternatively reverses the given
   linked list in groups of given size k. */
function kAltReverse(head, k)
{
    return _kAltReverse(head, k, true);
}
 
/* Helper function for kAltReverse().
   It reverses k nodes of the list only
   if the third parameter b is passed as
   true, otherwise moves the pointer k
   nodes ahead and recursively calls itself */
function _kAltReverse(node, k, b)
{
    if (node == null)
    {
        return null;
    }
 
    var count = 1;
    var prev = null;
    var current = node;
    var next = null;
 
    /* The loop serves two purposes
       1) If b is true, then it reverses
          the k nodes
       2) If b is false, then it moves the
          current pointer */
    while (current != null && count <= k)
    {
        next = current.next;
 
        // Reverse the nodes only if b is true
        if (b == true)
        {
            current.next = prev;
        }
 
        prev = current;
        current = next;
        count++;
    }
 
    /* 3) If b is true, then the node is the kth
          node. So attach the rest of the list
          after node.
       4) After attaching, return the new head */
    if (b == true)
    {
        node.next =
            _kAltReverse(current, k, !b);
        return prev;
    }
 
    /* If b is not true, then attach rest of
       the list after prev. So attach rest of
       the list after prev */
    else
    {
        prev.next = _kAltReverse(current, k, !b);
        return node;
    }
}
 
function printList(node)
{
    while (node != null)
    {
        document.write(node.data + " ");
        node = node.next;
    }
}
 
function push(newdata)
{
    var mynode = new Node(newdata);
    mynode.next = head;
    head = mynode;
}
 
// Creating the linkedlist
for (i = 20; i > 0; i--)
{
    push(i);
}
document.write("Given Linked List :<br/>");
printList(head);
head = kAltReverse(head, 3);
document.write("<br/>");
document.write("Modified Linked List :<br/>");
printList(head);
// This code is contributed by aashish1995
</script>


Output: 

Given linked list
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Modified Linked list
3 2 1 4 5 6 9 8 7 10 11 12 15 14 13 16 17 18 20 19

Time Complexity: O(n) 

Auxiliary Space: O(n) for call stack

Please refer complete article on Reverse alternate K nodes in a Singly Linked List for more details!



Previous Article
Next Article

Similar Reads

C++ Program For Reversing Alternate K Nodes In A Singly Linked List
Given a linked list, write a function to reverse every alternate k nodes (where k is an input to the function) in an efficient way. Give the complexity of your algorithm. Example: Inputs: 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;6-&gt;7-&gt;8-&gt;9-&gt;NULL and k = 3 Output: 3-&gt;2-&gt;1-&gt;4-&gt;5-&gt;6-&gt;9-&gt;8-&gt;7-&gt;NULL. Method 1 (Process 2k node
6 min read
Java Program For Reversing Alternate K Nodes In A Singly Linked List
Given a linked list, write a function to reverse every alternate k nodes (where k is an input to the function) in an efficient way. Give the complexity of your algorithm. Example: Inputs: 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;6-&gt;7-&gt;8-&gt;9-&gt;NULL and k = 3 Output: 3-&gt;2-&gt;1-&gt;4-&gt;5-&gt;6-&gt;9-&gt;8-&gt;7-&gt;NULL. Method 1 (Process 2k node
6 min read
Python Program For Reversing Alternate K Nodes In A Singly Linked List
Given a linked list, write a function to reverse every alternate k nodes (where k is an input to the function) in an efficient way. Give the complexity of your algorithm. Example: Inputs: 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;6-&gt;7-&gt;8-&gt;9-&gt;NULL and k = 3 Output: 3-&gt;2-&gt;1-&gt;4-&gt;5-&gt;6-&gt;9-&gt;8-&gt;7-&gt;NULL. Method 1 (Process 2k node
6 min read
Reverse alternate K nodes in a Singly Linked List
Given a linked list, write a function to reverse every alternate k nodes (where k is an input to the function) in an efficient way. Give the complexity of your algorithm. Example: Inputs: 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;6-&gt;7-&gt;8-&gt;9-&gt;NULL and k = 3 Output: 3-&gt;2-&gt;1-&gt;4-&gt;5-&gt;6-&gt;9-&gt;8-&gt;7-&gt;NULL. Method 1 (Process 2k node
22 min read
Alternate Odd and Even Nodes in a Singly Linked List
Given a singly linked list, rearrange the list so that even and odd nodes are alternate in the list.There are two possible forms of this rearrangement. If the first data is odd, then the second node must be even. The third node must be odd and so on. Notice that another arrangement is possible where the first node is even, second odd, third even an
23 min read
Reverse alternate K nodes in a Singly Linked List - Iterative Solution
Given a linked list and an integer K, the task is to reverse every alternate K nodes.Examples: Input: 1 -&gt; 2 -&gt; 3 -&gt; 4 -&gt; 5 -&gt; 6 -&gt; 7 -&gt; 8 -&gt; 9 -&gt; NULL, K = 3 Output: 3 2 1 4 5 6 9 8 7Input: 1 -&gt; 2 -&gt; 3 -&gt; 4 -&gt; 5 -&gt; 6 -&gt; 7 -&gt; 8 -&gt; 9 -&gt; NULL, K = 5 Output: 5 4 3 2 1 6 7 8 9 Approach: We have alre
12 min read
Javascript Program To Merge A Linked List Into Another Linked List At Alternate Positions
Given two linked lists, insert nodes of the second list into the first list at alternate positions of the first list. For example, if first list is 5-&gt;7-&gt;17-&gt;13-&gt;11 and second is 12-&gt;10-&gt;2-&gt;4-&gt;6, the first list should become 5-&gt;12-&gt;7-&gt;10-&gt;17-&gt;2-&gt;13-&gt;4-&gt;11-&gt;6 and second list should become empty. The
3 min read
Javascript Program For Arranging Single Linked List In Alternate Odd and Even Nodes Order
Given a singly linked list, rearrange the list so that even and odd nodes are alternate in the list.There are two possible forms of this rearrangement. If the first data is odd, then the second node must be even. The third node must be odd and so on. Notice that another arrangement is possible where the first node is even, second odd, third even an
8 min read
Javascript Program To Delete Alternate Nodes Of A Linked List
Given a Singly Linked List, starting from the second node delete all alternate nodes of it. For example, if the given linked list is 1-&gt;2-&gt;3-&gt;4-&gt;5 then your function should convert it to 1-&gt;3-&gt;5, and if the given linked list is 1-&gt;2-&gt;3-&gt;4 then convert it to 1-&gt;3. Recommended: Please solve it on "PRACTICE" first, before
3 min read
Convert Singly Linked List into Circular Linked List using JavaScript
We are given a singly linked list and we need to convert it into a circular linked list, where the last node points back to the head of the list. Converting a singly linked list into a circular linked list involves making the last node's next pointer point back to the head, creating a circular structure. This transformation enables traversal from t
3 min read