# Pairwise swap adjacent nodes of a linked list by changing pointers | Set 2

• Difficulty Level : Medium
• Last Updated : 15 Nov, 2022

Given a singly linked list, write a function to swap elements pairwise.

```Input : 1->2->3->4->5->6->7
Output : 2->1->4->3->6->5->7,

Input : 1->2->3->4->5->6
Output : 2->1->4->3->6->5```

A solution has been discussed set 1. Here a simpler solution is discussed. We explicitly change pointers of first two nodes, then fix remaining nodes.

Implementation:

## C++

 `/* This program swaps the nodes of linked list``   ``rather than swapping the field from the nodes.``   ``Imagine a case where a node contains many``   ``fields, there will be plenty of unnecessary``   ``swap calls. */``#include``using` `namespace` `std;` `/* A linked list node */``struct` `Node``{``    ``int` `data;``    ``struct` `Node *next;``};` `/* Function to pairwise swap elements of a``   ``linked list */``Node *pairWiseSwap(Node *head)``{``    ``// If linked list is empty or there is only``    ``// one node in list``    ``if` `(head == NULL || head->next == NULL)``        ``return` `head;` `    ``// Fix the head and its next explicitly to``    ``// avoid many if else in while loop``    ``Node *curr = head->next->next;``    ``Node *prev = head;``    ``head = head->next;``    ``head->next = prev;` `    ``// Fix remaining nodes``    ``while` `(curr != NULL && curr->next != NULL)``    ``{``        ``prev->next = curr->next;``        ``prev = curr;``        ``Node *next = curr->next->next;``        ``curr->next->next = curr;``        ``curr = next;``    ``}``    ` `    ``prev->next = curr;` `    ``return` `head;``}` `/* Function to add a node at the beginning of``   ``Linked List */``void` `push(``struct` `Node** head_ref, ``int` `new_data)``{``    ``struct` `Node* new_node = ``new` `Node;``    ``new_node->data = new_data;``    ``new_node->next = (*head_ref);``    ``(*head_ref) = new_node;``}` `/* Function to print nodes in a given linked list */``void` `printList(``struct` `Node *node)``{``    ``while` `(node != NULL)``    ``{``        ``printf``(``"%d "``, node->data);``        ``node = node->next;``    ``}``}` `/* Driver program to test above function */``int` `main()``{``    ``struct` `Node *start = NULL;` `    ``/* The constructed linked list is:``    ``1->2->3->4->5->6->7 */``    ``push(&start, 7);``    ``push(&start, 6);``    ``push(&start, 5);``    ``push(&start, 4);``    ``push(&start, 3);``    ``push(&start, 2);``    ``push(&start, 1);` `    ``printf``(``"\n Linked list before calling pairWiseSwap() "``);``    ``printList(start);` `    ``start = pairWiseSwap(start);` `    ``printf``(``"\n Linked list after calling pairWiseSwap() "``);``    ``printList(start);` `    ``return` `0;``}`

## Java

 `/* This program swaps the nodes of linked list``rather than swapping the field from the nodes.``Imagine a case where a node contains many``fields, there will be plenty of unnecessary``swap calls. */``class` `GfG``{` `/* A linked list node */``static` `class` `Node``{``    ``int` `data;``    ``Node next;``}``static` `Node head = ``null``;` `/* Function to pairwise swap elements of a``linked list */``static` `Node pairWiseSwap(Node head)``{``    ` `    ``// If linked list is empty or there is only``    ``// one node in list``    ``if` `(head == ``null` `|| head.next == ``null``)``        ``return` `head;` `    ``// Fix the head and its next explicitly to``    ``// avoid many if else in while loop``    ``Node curr = head.next.next;``    ``Node prev = head;``    ``head = head.next;``    ``head.next = prev;` `    ``// Fix remaining nodes``    ``while` `(curr != ``null` `&& curr.next != ``null``)``    ``{``        ``prev.next = curr.next;``        ``prev = curr;``        ``Node next = curr.next.next;``        ``curr.next.next = curr;``        ``curr = next;``    ``}``    ` `    ``prev.next = curr;` `    ``return` `head;``}` `/* Function to add a node at the``beginning of Linked List */``static` `void` `push(``int` `new_data)``{``    ``Node new_node = ``new` `Node();``    ``new_node.data = new_data;``    ``new_node.next = (head);``    ``(head) = new_node;``}` `/* Function to print nodes in a given linked list */``static` `void` `printList(Node node)``{``    ``while` `(node != ``null``)``    ``{``        ``System.out.print(node.data + ``" "``);``        ``node = node.next;``    ``}``}` `/* Driver code */``public` `static` `void` `main(String[] args)``{``    ``//Node head = null;` `    ``/* The constructed linked list is:``    ``1->2->3->4->5->6->7 */``    ``push( ``7``);``    ``push( ``6``);``    ``push( ``5``);``    ``push( ``4``);``    ``push(``3``);``    ``push( ``2``);``    ``push( ``1``);` `    ``System.out.print(``"\n Linked list before calling pairWiseSwap() "``);``    ``printList(head);` `    ``Node start = pairWiseSwap(head);` `    ``System.out.print(``"\n Linked list after calling pairWiseSwap() "``);``    ``printList(start);``}``}` `// This code is contributed by Prerna Saini.`

## Python3

 `# This program swaps the nodes of linked list``# rather than swapping the field from the nodes.``# Imagine a case where a node contains many``# fields, there will be plenty of unnecessary``# swap calls.`` ` `# A linked list node``class` `Node:``    ` `    ``def` `__init__(``self``, data):``        ` `        ``self``.data ``=` `data``        ``self``.``next` `=` `None``    ` `# Function to pairwise swap elements of a``# linked list``def` `pairWiseSwap(head):` `    ``# If linked list is empty or there is only``    ``# one node in list``    ``if` `(head ``=``=` `None` `or` `head.``next` `=``=` `None``):``        ``return` `head`` ` `    ``# Fix the head and its next explicitly to``    ``# avoid many if else in while loop``    ``curr ``=` `head.``next``.``next``    ``prev ``=` `head``    ``head ``=` `head.``next``    ``head.``next` `=` `prev`` ` `    ``# Fix remaining nodes``    ``while` `(curr !``=` `None` `and` `curr.``next` `!``=` `None``):``        ``prev.``next` `=` `curr.``next``        ``prev ``=` `curr``        ``next` `=` `curr.``next``.``next``        ``curr.``next``.``next` `=` `curr``        ``curr ``=` `next``    ` `    ``prev.``next` `=` `curr`` ` `    ``return` `head` `# Function to add a node at the beginning``# of Linked List``def` `push(head_ref, new_data):` `    ``new_node ``=` `Node(new_data)``    ``new_node.``next` `=` `(head_ref)``    ``(head_ref) ``=` `new_node``    ``return` `head_ref` `# Function to print nodes in a``# given linked list``def` `printList(node):` `    ``while` `(node !``=` `None``):``        ``print``(node.data, end ``=` `' '``)``        ``node ``=` `node.``next``    ` `# Driver Code``if` `__name__``=``=``'__main__'``:` `    ``start ``=` `None`` ` `    ``# The constructed linked list is:``    ``# 1.2.3.4.5.6.7``    ``start ``=` `push(start, ``7``)``    ``start ``=` `push(start, ``6``)``    ``start ``=` `push(start, ``5``)``    ``start ``=` `push(start, ``4``)``    ``start ``=` `push(start, ``3``)``    ``start ``=` `push(start, ``2``)``    ``start ``=` `push(start, ``1``)`` ` `    ``print``(``"\nLinked list before "``          ``"calling pairWiseSwap() "``, end ``=` `'')``    ``printList(start)`` ` `    ``start ``=` `pairWiseSwap(start)`` ` `    ``print``(``"\nLinked list after calling "``          ``"pairWiseSwap() "``, end ``=` `'')``    ``printList(start)`` ` `# This code is contributed by rutvik_56`

## C#

 `/* This program swaps the nodes of linked list``rather than swapping the field from the nodes.``Imagine a case where a node contains many``fields, there will be plenty of unnecessary``swap calls. */``using` `System;` `class` `GfG``{` `/* A linked list node */``class` `Node``{``    ``public` `int` `data;``    ``public` `Node next;``}``static` `Node head = ``null``;` `/* Function to pairwise swap ``elements of a linked list */``static` `Node pairWiseSwap(Node head)``{``    ` `    ``// If linked list is empty or there``    ``//  is only one node in list``    ``if` `(head == ``null` `|| head.next == ``null``)``        ``return` `head;` `    ``// Fix the head and its next explicitly to``    ``// avoid many if else in while loop``    ``Node curr = head.next.next;``    ``Node prev = head;``    ``head = head.next;``    ``head.next = prev;` `    ``// Fix remaining nodes``    ``while` `(curr != ``null` `&& curr.next != ``null``)``    ``{``        ``prev.next = curr.next;``        ``prev = curr;``        ``Node next = curr.next.next;``        ``curr.next.next = curr;``        ``curr = next;``    ``}``    ` `    ``prev.next = curr;``    ``return` `head;``}` `/* Function to add a node at the``beginning of Linked List */``static` `void` `push(``int` `new_data)``{``    ``Node new_node = ``new` `Node();``    ``new_node.data = new_data;``    ``new_node.next = (head);``    ``(head) = new_node;``}` `/* Function to print nodes``in a given linked list */``static` `void` `printList(Node node)``{``    ``while` `(node != ``null``)``    ``{``        ``Console.Write(node.data + ``" "``);``        ``node = node.next;``    ``}``}` `/* Driver code */``public` `static` `void` `Main()``{``    ``//Node head = null;` `    ``/* The constructed linked list is:``    ``1->2->3->4->5->6->7 */``    ``push( 7);``    ``push( 6);``    ``push( 5);``    ``push( 4);``    ``push(3);``    ``push( 2);``    ``push( 1);` `    ``Console.Write(``"\n Linked list before"` `+``                ``"calling pairWiseSwap() "``);``    ``printList(head);` `    ``Node start = pairWiseSwap(head);` `    ``Console.Write(``"\n Linked list after"` `+``                ``"calling pairWiseSwap() "``);``    ``printList(start);``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output

``` Linked list before calling pairWiseSwap() 1 2 3 4 5 6 7
Linked list after calling pairWiseSwap() 2 1 4 3 6 5 7 ```

Another approach: The approach here is to use the double pointers so that we need not update the head pointer during swap separately.

Implementation:

## C++

 `#include ``using` `namespace` `std;` `// A nexted list node``struct` `Node {``  ``int` `data;``  ``struct` `Node* next;``};` `/* Function to insert a node at the beginning */``void` `push(``struct` `Node** head_ref, ``int` `new_data)``{``  ``struct` `Node* new_node``    ``= (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));``  ``new_node->data = new_data;``  ``new_node->next = (*head_ref);``  ``(*head_ref) = new_node;``}` `/* Utility function to print a singly linked list */``void` `printList(``struct` `Node* head)``{``  ``struct` `Node* temp = head;``  ``while` `(temp != NULL) {``    ``cout << temp->data << ``" "``;``    ``temp = temp->next;``  ``}``  ``cout << endl;``}` `// Function to swap adjacent nodes``void` `swapPairs(``struct` `Node** head)``{``  ``// Loop until we reach the last node``  ``while` `(*head && (*head)->next) {``    ``struct` `Node* one = *head;` `    ``struct` `Node* two = one->next->next;` `    ``*head = one->next;` `    ``one->next->next = one;` `    ``one->next = two;` `    ``head = &one->next;``  ``}``}` `// Driver program to test above functions``int` `main()``{``  ``struct` `Node* head = NULL;``  ``push(&head, 6);``  ``push(&head, 5);``  ``push(&head, 4);``  ``push(&head, 3);``  ``push(&head, 2);``  ``push(&head, 1);` `  ``cout << (``"Actual List:\n"``);``  ``printList(head);` `  ``swapPairs(&head);` `  ``cout << (``"ModifiedLinked List:\n"``);``  ``printList(head);``}` `// This code is contributed by garg28harsh.`

## C

 `#include ``#include ` `// A nexted list node``struct` `Node``{``    ``int` `data;``    ``struct` `Node *next;``};` `/* Function to insert a node at the beginning */``void` `push(``struct` `Node ** head_ref, ``int` `new_data)``{``    ``struct` `Node* new_node =``        ``(``struct` `Node*) ``malloc``(``sizeof``(``struct` `Node));``    ``new_node->data = new_data;``    ``new_node->next = (*head_ref);``    ``(*head_ref) = new_node;``}` `/* Utility function to print a singly linked list */``void` `printList(``struct` `Node *head)``{``    ``struct` `Node *temp = head;``    ``while` `(temp != NULL)``    ``{``        ``printf``(``"%d "``, temp->data);``        ``temp = temp->next;``    ``}``    ``printf``(``"\n"``);``}` `// Function to swap adjacent nodes``void` `swapPairs(``struct` `Node **head)``{``    ``//Loop until we reach the last node``    ``while``(*head && (*head)->next)``    ``{``        ``struct` `Node *one = *head;``        ` `        ``struct` `Node *two = one->next->next;``        ` `        ``*head = one->next;``        ` `        ``one->next->next = one;``        ` `        ``one->next = two;``        ` `        ``head = &one->next;``    ``}``}` `// Driver program to test above functions``int` `main()``{``    ``struct` `Node *head = NULL;``    ``push(&head, 6);``    ``push(&head, 5);``    ``push(&head, 4);``    ``push(&head, 3);``    ``push(&head, 2);``    ``push(&head, 1);` `    ``printf``(``"Actual List:\n"``);``    ``printList(head);` `    ``swapPairs(&head);` `    ``printf``(``"ModifiedLinked List:\n"``);``    ``printList(head);` `    ``getchar``();``    ``return` `0;``}`

Output

```Actual List:
1 2 3 4 5 6