# JavaScript program for Swapping Nodes in A Linked List Without Swapping Data

JavaScript program for Swapping Nodes in A Linked List Without Swapping Data is a familiar problem in web development that involves rearranging the order of nodes in a linked list. A linked list is a data structure that consists of nodes, each containing a piece of data and a reference to the next node in the list.

In this article, we will learn a complete tutorial about swapping nodes in a linked list without swapping data using JavaScript. So let’s get started by defining swapping nodes first and then we move ahead in this tutorial. So, Keep learning!

## Swapping Nodes

Swapping nodes in a linked list means that we are exchanging the positions of two nodes. There are different approaches to swapping nodes in a linked list. One way is to swap the data in the nodes, but this can be inefficient when dealing with large amounts of data. Another way is to swap the pointers of the nodes. This is more efficient because we do not need to copy any data.

Let’s understand swapping nodes with an example

### Example

Suppose we have a linked list that looks like this −

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

We want to swap the second and fourth nodes to get:

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

To do this without swapping the data in the nodes, we need to modify the links between the nodes. The resulting linked list should have the same data as the original, but with the order of the nodes changed.

So, we start by identifying the two nodes we want to swap: node 2 and node 4. We also need to keep track of the nodes that come before and after these nodes in the list.

In this case, the nodes before and after node 2 are 1 and 3, respectively. The nodes before and after node 4 are 3 and 5, respectively.

Next, we need to update the links between the nodes. We start by setting the next pointer of the node before node 2 to node 4. Then, we set the next pointer of node 2 to node 5 (since node 4 now comes after node 2). Finally, we set the next pointer of node 4 to node 3 (since node 2 now comes after node 4).

The resulting linked list looks like this −

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

Note − The data in each node has not changed, only the order of the nodes.

Now let’s see the algorithm we are going to use for Swapping Nodes in A Linked List Without Swapping Data.

## Algorithm

STEP1: Identify the two nodes that need to be swapped

The first step is to identify the two nodes that need to be swapped. Let's say we want to swap node A and node B.

STEP 2: Find the previous nodes of both the nodes to be swapped

We need to find the nodes that come before nodes A and B in the linked list. Let's call these nodes PrevA and PrevB, respectively.

STEP 3: Update the next pointers of the previous nodes to point to the other node

Now, we need to update the next pointers of PrevA and PrevB to point to the correct nodes. This involves updating PrevA's next pointer to point to node B, and PrevB's next pointer to point to node A.

STEP 4: Update the next pointers of the nodes to be swapped to point to the correct nodes

Next, we need to update the next pointers of nodes A and B to point to the correct nodes. This involves updating node A's next pointer to point to node B's next node, and node B's next pointer to point to node A's next node.

STEP 5: Repeat the above steps for any additional nodes that need to be swapped

If we need to swap more than two nodes, we can repeat the above steps for each pair of nodes that needs to be swapped.

After completing these steps, the nodes will be swapped in the linked list without swapping their data. Now Let’s understand the above algorithm with an example where we implement this algorithm using Javascript.

## Example

In this program, we first define a 'Node' class to create nodes of the linked list, and a 'LinkedList' class to create and manipulate the linked list. The 'swapNodes' function in the 'LinkedList' class implements the swapping algorithm described earlier.

// Define a Node class to create nodes of linked list
class Node {
constructor(data) {
this.data = data;
this.next = null;
}
}
// Define a LinkedList class to create and manipulate the linked list
constructor() {
}
// Function to swap two nodes in the linked list
swapNodes(node1, node2) {
// If both nodes are the same, no need to swap
if (node1 === node2) {
return;
}
// Find the previous nodes of both nodes to be swapped
let prevNode1 = null;
while (currentNode1 && currentNode1 !== node1) {
prevNode1 = currentNode1;
currentNode1 = currentNode1.next;
}
let prevNode2 = null;
while (currentNode2 && currentNode2 !== node2) {
prevNode2 = currentNode2;
currentNode2 = currentNode2.next;
}
if (!currentNode1 || !currentNode2) {
return;
}
// Update the next pointers of the previous nodes to point to the other node
if (prevNode1) {
prevNode1.next = currentNode2;
} else {
}
if (prevNode2) {
prevNode2.next = currentNode1;
} else {
}
// Swap the next pointers of the nodes to be swapped to point to the correct nodes
let temp = currentNode1.next;
currentNode1.next = currentNode2.next;
currentNode2.next = temp;
// Print the swapped linked list
while (current) {
process.stdout.write(current.data + " -> ");
current = current.next;
}
console.log("null");
}
// Function to add a Node at the end of the linked list
let node = new Node(data);
} else {
while (current.next) {
current = current.next;
}
current.next = node;
}
}
}
// Print the original linked list
while (current) {
process.stdout.write(current.data + " -> ");
current = current.next;
}
console.log("null");
// Swap node 2 and node 4


## Conclusion

In this tutorial, we have presented a JavaScript program that implements this algorithm, and it successfully swaps nodes in the linked list without swapping their data. Hope it helps our readers. Happy Learning!

Updated on: 17-Apr-2023

124 Views