# Pairwise swap elements of a given linked list by changing links

**Introduction:**

You are given a LinkedList and you need to pairwise swap the elements of the LinkedList by changing their links.

Let us see a few examples:

**Input 1:**

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

**Output 1:**

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

**Input 2:**

1 -> 2 -> 3 -> 4

**Output 2:**

2 -> 1 -> 4 -> 3

**Approach:**

We will maintain the following 3 pointers:

- current: We will use this pointer to traverse the LinkedList.
- prev: This will point to the previous pointer of the current node.
- nextOfCur: This will point to the next pointer of the current node.

At any node we will do the following:

- First, we will set the next of current to be prev i.e. current.next = prev.
- Then, we will set the next of prev to be the next of nextOfCur i.e. prev.next = nextOfCur.next.
- Then we will update the prev and current pointers.

Refer to the below implementation of the above approach.

public Node pairWiseSwap(Node head){ /* If the linked list is empty or there is only one node in list */ if (head == null || head.next == null) { return head; } // Initialize the previous and current pointers Node prev = head; Node current = head.next; head = current; // Traversing the list while (true) { Node nextOfCur = current.next; /* Updating the next of the current pointer to be prev. */ current.next = prev; // If next is NULL or next is the last node if (nextOfCur == null || nextOfCur.next == null) { prev.next = nextOfCur; break; } // Change next of previous to next next prev.next = nextOfCur.next; // Update the previous and current prev = nextOfCur; current = prev.next; } return head; } |

**Time Complexity:** The time complexity for the above approach to pairwise swap the elements of the Linked List is O(N) (where ‘N’ is the number of nodes in the Linked List) because we are just iterating the Linked List once.

**Space Complexity:** The space complexity of the above approach to pairwise swap the elements of the Linked List is O(1) because we are using the constant auxiliary space.

**FAQs:**

- What are prev, current, and next pointing to when we pairwise swap the elements of the Linked List?

current: We will use this pointer to traverse the LinkedList.

prev: This will point to the previous pointer of the current node.

nextOfCur: This will point to the next pointer of the current node. - What is the time complexity for the approach we have used to pairwise swap the elements of the Linked List?
- The time complexity for the approach to pairwise swap the elements of the Linked List is O(N) (where N is the number of nodes in the Linked List) because we are just iterating the Linked List once.

- Is there any other method to solve this problem?
- Yes, we can also solve this question by just swapping the data of adjacent nodes instead of changing the links of the nodes.

**Key Takeaways: **

In this blog, we have covered the following things:

- We first discussed the approach to pairwise swap the elements of the Linked List.
- Then we implemented the approach we discussed.

If you want to learn more about Linked List and want to practice some questions which require you to take your basic knowledge on Linked List a notch higher, then you can visit our __Guided Path for Linked List__. To practice this problem, you can visit __Practice Problem__.

Until then, All the best for your future endeavors, and Keep Coding.

Comments

## No comments yet

## Be the first to share what you think