Open In App

Javascript Program For Swapping Kth Node From Beginning With Kth Node From End In A Linked List

Last Updated : 17 Aug, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

Given a singly linked list, swap kth node from beginning with kth node from end. Swapping of data is not allowed, only pointers should be changed. This requirement may be logical in many situations where the linked list data part is huge (For example student details line Name, RollNo, Address, ..etc). The pointers are always fixed (4 bytes for most of the compilers).
Example:

Input: 1 -> 2 -> 3 -> 4 -> 5, K = 2
Output: 1 -> 4 -> 3 -> 2 -> 5 
Explanation: The 2nd node from 1st is 2 and 
2nd node from last is 4, so swap them.

Input: 1 -> 2 -> 3 -> 4 -> 5, K = 5
Output: 5 -> 2 -> 3 -> 4 -> 1 
Explanation: The 5th node from 1st is 5 and 
5th node from last is 1, so swap them.

Illustration:

Approach: The idea is very simple find the k th node from the start and the kth node from last is n-k+1 th node from start. Swap both the nodes. 
However there are some corner cases, which must be handled

  1. Y is next to X
  2. X is next to Y
  3. X and Y are same
  4. X and Y don’t exist (k is more than number of nodes in linked list)

Below is the implementation of the above approach.

Javascript




<script>
// A javascript program to swap kth
// node from the beginning with
// kth node from the end
class Node 
{
    constructor(val) 
    {
        this.data = val;
        this.next = null;
    }
}
   
var head;
  
/* Utility function to insert a node 
   at the beginning */
function push(new_data) 
{
    new_node = new Node(new_data);
    new_node.next = head;
    head = new_node;
}
  
/* Utility function for displaying 
   linked list */
function printList()
{
    node = head;
    while (node != null
    {
         document.write(node.data + " ");
         node = node.next;
    }
    document.write("");
}
  
/* Utility function for calculating length 
   of linked list */
function countNodes() 
{
    var count = 0;
    s = head;
    while (s != null)
    {
        count++;
        s = s.next;
    }
    return count;
}
  
/* Function for swapping kth nodes from 
   both ends of linked list */
function swapKth(k)
{
    // Count nodes in linked list
    var n = countNodes();
  
    // Check if k is valid
    if (n < k)
        return;
  
    // If x (kth node from start) and
    // y(kth node from end) are same
    if (2 * k - 1 == n)
        return;
  
    // Find the kth node from beginning 
    // of linked list. We also find previous 
    // of kth node because we need to update 
    // next pointer of the previous.
    x = head;
    x_prev = null;
    for (i = 1; i < k; i++)
    {
        x_prev = x;
        x = x.next;
    }
  
    // Similarly, find the kth node from end 
    // and its previous. kth node from end 
    // is (n-k+1)th node from beginning
    y = head;
    y_prev = null;
    for (i = 1; i < n - k + 1; i++)
    {
        y_prev = y;
        y = y.next;
     }
  
     // If x_prev exists, then new next of it 
     // will be y. Consider the case when y->next 
     // is x, in this case, x_prev and y are same. 
     // So the statement "x_prev->next = y" creates 
     // a self loop. This self loop will be broken 
     // when we change y->next.
     if (x_prev != null)
         x_prev.next = y;
  
      // Same thing applies to y_prev
      if (y_prev != null)
          y_prev.next = x;
  
      // Swap next pointers of x and y. These 
      // statements also break self loop if 
      // x->next is y or y->next is x
      temp = x.next;
      x.next = y.next;
      y.next = temp;
  
      // Change head pointers when k is 1 or n
      if (k == 1)
          head = y;
  
      if (k == n)
          head = x;
}
  
// Driver code
for (let i = 8; i >= 1; i--)
    push(i);
  
document.write(
"Original linked list: <br/>");
printList();
document.write("<br/>");
  
for (let i = 1; i < 9; i++)
{
    swapKth(i);
    document.write(
    "Modified List for k = " + i + "<br/>");
    printList();
    document.write("<br/>");
}
// This code is contributed by gauravrajput1 
</script>


Output:

Original Linked List: 1 2 3 4 5 6 7 8
Modified List for k = 1
8 2 3 4 5 6 7 1

Modified List for k = 2
8 7 3 4 5 6 2 1

Modified List for k = 3
8 7 6 4 5 3 2 1

Modified List for k = 4
8 7 6 5 4 3 2 1

Modified List for k = 5
8 7 6 4 5 3 2 1

Modified List for k = 6
8 7 3 4 5 6 2 1

Modified List for k = 7
8 2 3 4 5 6 7 1

Modified List for k = 8
1 2 3 4 5 6 7 8

Complexity Analysis:

  • Time Complexity: O(n), where n is the length of the list. 
    One traversal of the list is needed.
  • Auxiliary Space: O(1). 
    No extra space is required.

Please refer complete article on Swap Kth node from beginning with Kth node from end in a Linked List for more details!



Previous Article
Next Article

Similar Reads

C++ Program For Swapping Kth Node From Beginning With Kth Node From End In A Linked List
Given a singly linked list, swap kth node from beginning with kth node from end. Swapping of data is not allowed, only pointers should be changed. This requirement may be logical in many situations where the linked list data part is huge (For example student details line Name, RollNo, Address, ..etc). The pointers are always fixed (4 bytes for most
5 min read
Java Program For Swapping Kth Node From Beginning With Kth Node From End In A Linked List
Given a singly linked list, swap kth node from beginning with kth node from end. Swapping of data is not allowed, only pointers should be changed. This requirement may be logical in many situations where the linked list data part is huge (For example student details line Name, RollNo, Address, ..etc). The pointers are always fixed (4 bytes for most
5 min read
Python Program For Swapping Kth Node From Beginning With Kth Node From End In A Linked List
Given a singly linked list, swap kth node from beginning with kth node from end. Swapping of data is not allowed, only pointers should be changed. This requirement may be logical in many situations where the linked list data part is huge (For example student details line Name, RollNo, Address, ..etc). The pointers are always fixed (4 bytes for most
5 min read
Swap Kth node from beginning with Kth node from end in a Doubly Linked List
Prerequisites: Doubly Linked List Given a doubly-linked list, the task is to swap Kth node from the beginning with Kth node from the ending.Note: Please note here the nodes are swapped and not the data in the nodes. Examples: Input: DLL = 1 &lt;-&gt; 2 &lt;-&gt; 3 &lt;-&gt; 4 &lt;-&gt; 5 &lt;-&gt; 6, K = 3 Output: 1 2 4 3 5 6 Explanation: Third nod
31 min read
Swap Kth node from beginning with Kth node from end in a Linked List
Given a singly linked list, swap kth node from beginning with kth node from end. Swapping of data is not allowed, only pointers should be changed. This requirement may be logical in many situations where the linked list data part is huge (For example student details like Name, RollNo, Address, ..etc). The pointers are always fixed (4 bytes for most
17 min read
Delete Kth nodes from the beginning and end of a Linked List
Given a singly Linked List and an integer K denoting the position of a Linked List, the task is to delete the Kth node from the beginning and end of the Linked List. Examples: Input: 1 ? 2 ? 3 ? 4 ? 5 ? 6, K = 3Output: 1 ? 2 ? 5 ? 6Explanation: Deleted Nodes : 3, 4 Input: 1 ? 2 ? 3 ? 4 ? 5 ? 6, K = 1Output: 2 ? 3 ? 4 ? 5 Input: 1 ? 2 ? 3 ? 4 ? 5 ?
13 min read
Javascript Program For Swapping Nodes In A Linked List Without Swapping Data
Given a linked list and two keys in it, swap nodes for two given keys. Nodes should be swapped by changing links. Swapping data of nodes may be expensive in many situations when data contains many fields. It may be assumed that all keys in the linked list are distinct. Examples: Input : 10-&gt;15-&gt;12-&gt;13-&gt;20-&gt;14, x = 12, y = 20 Output:
6 min read
Swap first odd and even valued nodes from the beginning and end of a Linked List
Given a singly Linked List, the task is to swap the first odd valued node from the beginning and the first even valued node from the end of the Linked List. If the list contains node values of a single parity, then no modifications are required. Examples: Input: 4 -&gt; 3 -&gt; 5 -&gt; 2 -&gt; 3 -&gt; NULLOutput: 4 -&gt; 2 -&gt; 5 -&gt; 3 -&gt; 3 -
13 min read
C++ Program For Swapping Nodes In A Linked List Without Swapping Data
Given a linked list and two keys in it, swap nodes for two given keys. Nodes should be swapped by changing links. Swapping data of nodes may be expensive in many situations when data contains many fields. It may be assumed that all keys in the linked list are distinct. Examples: Input : 10-&gt;15-&gt;12-&gt;13-&gt;20-&gt;14, x = 12, y = 20 Output:
5 min read
C Program For Swapping Nodes In A Linked List Without Swapping Data
Given a linked list and two keys in it, swap nodes for two given keys. Nodes should be swapped by changing links. Swapping data of nodes may be expensive in many situations when data contains many fields. It may be assumed that all keys in the linked list are distinct. Examples: Input : 10-&gt;15-&gt;12-&gt;13-&gt;20-&gt;14, x = 12, y = 20 Output:
4 min read