- Trending Categories
- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- MS Excel
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP
- Physics
- Chemistry
- Biology
- Mathematics
- English
- Economics
- Psychology
- Social Studies
- Fashion Studies
- Legal Studies

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

# 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 class LinkedList { constructor() { this.head = null; } // 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; let currentNode1 = this.head; while (currentNode1 && currentNode1 !== node1) { prevNode1 = currentNode1; currentNode1 = currentNode1.next; } let prevNode2 = null; let currentNode2 = this.head; while (currentNode2 && currentNode2 !== node2) { prevNode2 = currentNode2; currentNode2 = currentNode2.next; } // If either node1 or node2 is not found, return if (!currentNode1 || !currentNode2) { return; } // Update the next pointers of the previous nodes to point to the other node if (prevNode1) { prevNode1.next = currentNode2; } else { this.head = currentNode2; } if (prevNode2) { prevNode2.next = currentNode1; } else { this.head = currentNode1; } // 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 console.log("Swapped linked list:"); let current = this.head; 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 addNode(data) { let node = new Node(data); if (!this.head) { this.head = node; } else { let current = this.head; while (current.next) { current = current.next; } current.next = node; } } } // Create a linked list let linkedList = new LinkedList(); linkedList.addNode(1); linkedList.addNode(2); linkedList.addNode(3); linkedList.addNode(4); // Print the original linked list console.log("Original linked list:"); let current = linkedList.head; while (current) { process.stdout.write(current.data + " -> "); current = current.next; } console.log("null"); // Swap node 2 and node 4 let node2 = linkedList.head.next; let node4 = linkedList.head.next.next.next; linkedList.swapNodes(node2, node4);

## 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!