Pairwise swap adjacent nodes of a linked list by changing pointers | Set 2
Last Updated :
11 Feb, 2023
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<bits/stdc++.h>
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;
}
/* 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.
# 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
/* 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
<script>
/* 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
{
constructor()
{
this.data = 0;
this.next = null;
}
}
var head = null;
/* Function to pairwise swap
elements of a linked list */
function pairWiseSwap(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
var curr = head.next.next;
var prev = head;
head = head.next;
head.next = prev;
// Fix remaining nodes
while (curr != null && curr.next != null)
{
prev.next = curr.next;
prev = curr;
var 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 */
function push(new_data)
{
var 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 */
function printList(node)
{
while (node != null)
{
document.write(node.data + " ");
node = node.next;
}
}
/* Driver code */
/* 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);
document.write("Linked list before" +
"calling pairWiseSwap() ");
printList(head);
var start = pairWiseSwap(head);
document.write("<br> Linked list after" +
"calling pairWiseSwap() ");
printList(start);
</script>
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
Time complexity : O(n)
Auxiliary Space: O(1)
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 <bits/stdc++.h>
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.
#include <stdio.h>
#include <stdlib.h>
// 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;
}
/*package whatever //do not write package name here */
import java.io.*;
import java.util.Scanner;
class Node {
int data;
Node next;
Node(int d)
{
data = d;
next = null;
}
}
class LinkedList {
Node head;
// Function to insert a node at the beginning
void push(int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
// Utility function to print a singly linked list
void printList()
{
Node temp = head;
while (temp != null) {
System.out.print(temp.data + " ");
temp = temp.next;
}
System.out.println();
}
void swapPairs(Node head)
{
Node current = head;
// Loop until we reach the last node
while (current != null && current.next != null) {
int temp = current.data;
current.data = current.next.data;
current.next.data = temp;
current = current.next.next;
}
}
public static void main(String[] args)
{
LinkedList list = new LinkedList();
list.push(6);
list.push(5);
list.push(4);
list.push(3);
list.push(2);
list.push(1);
System.out.println("Actual List:");
list.printList();
list.swapPairs(list.head);
System.out.println("Modified Linked List:");
list.printList();
}
}
using System;
class Node {
public int data;
public Node next;
public Node(int d)
{
data = d;
next = null;
}
}
class LinkedList {
public Node head;
// Function to insert a node at the beginning
public void push(int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
// Utility function to print a singly linked list
public void printList()
{
Node temp = head;
while (temp != null) {
Console.Write(temp.data + " ");
temp = temp.next;
}
Console.WriteLine();
}
public void swapPairs(Node head)
{
Node current = head;
// Loop until we reach the last node
while (current != null && current.next != null) {
int temp = current.data;
current.data = current.next.data;
current.next.data = temp;
current = current.next.next;
}
}
public static void Main(string[] args)
{
LinkedList list = new LinkedList();
list.push(6);
list.push(5);
list.push(4);
list.push(3);
list.push(2);
list.push(1);
Console.WriteLine("Actual List:");
list.printList();
list.swapPairs(list.head);
Console.WriteLine("Modified Linked List:");
list.printList();
}
} // this code is contributed by devendra
class Node {
constructor(data) {
this.data = data;
this.next = null;
}
}
// Function to insert a node at the beginning
function push(list, newData) {
let newNode = new Node(newData);
newNode.next = list.head;
list.head = newNode;
}
// Utility function to print a singly linked list
function printList(head) {
let temp = head;
while (temp !== null) {
console.log(temp.data);
temp = temp.next;
}
}
// Function to swap adjacent nodes
function swapPairs(list) {
let head = list.head;
let dummy = new Node(null);
dummy.next = head;
let prev = dummy;
while (head && head.next) {
let one = head;
let two = one.next.next;
prev.next = one.next;
one.next.next = one;
one.next = two;
prev = one;
head = one.next;
}
list.head = dummy.next;
}
let list = {head: null};
push(list, 6);
push(list, 5);
push(list, 4);
push(list, 3);
push(list, 2);
push(list, 1);
console.log("Actual List:");
printList(list.head);
swapPairs(list);
console.log("Modified Linked List:");
printList(list.head);
class Node:
def __init__(self, data):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = None
# Function to insert a node at the beginning
def push(self, new_data):
new_node = Node(new_data)
new_node.next = self.head
self.head = new_node
# Utility function to print a singly linked list
def printList(self):
temp = self.head
while temp:
print(temp.data, end=" ")
temp = temp.next
print()
def swapPairs(self, head):
current = head
# Loop until we reach the last node
while current and current.next:
temp = current.data
current.data = current.next.data
current.next.data = temp
current = current.next.next
# Test
linked_list = LinkedList()
linked_list.push(6)
linked_list.push(5)
linked_list.push(4)
linked_list.push(3)
linked_list.push(2)
linked_list.push(1)
print("Actual List:")
linked_list.printList()
linked_list.swapPairs(linked_list.head)
print("Modified Linked List:")
linked_list.printList()
# this code is contributed by writer
OutputActual List:
1 2 3 4 5 6
ModifiedLinked List:
2 1 4 3 6 5
Time complexity: O(n), where n is the number of nodes in the linked list. This is because the code iterates through each node in the linked list once and performs a constant amount of operations on each node.
Auxiliary Space: O(1)
Similar Reads
Pairwise Swap Nodes of a given linked list by changing links Given a singly linked list, write a function to swap elements pairwise. For example, if the linked list is 1->2->3->4->5->6->7 then the function should change it to 2->1->4->3->6->5->7, and if the linked list is 1->2->3->4->5->6 then the function sh
15+ min read
Pairwise Swap Elements of a given Linked List Given a singly linked list, the task is to swap linked list elements pairwise.Examples:Input : 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULL Output : 2 -> 1 -> 4 -> 3 -> 6 -> 5 -> NULL Input : 1 -> 2 -> 3 -> 4 -> 5 -> NULL Output : 2 -> 1 -> 4 -> 3 -
12 min read
Reverse the order of all nodes at even position in given Linked List Given a linked list A[] of N integers, the task is to reverse the order of all integers at an even position. Examples: Input: A[] = 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULLOutput: 1 6 3 4 5 2Explanation: Nodes at even position in the given linked list are 2, 4 and 6. So, after reversing
10 min read
XOR Linked List - Pairwise swap elements of a given linked list Given a XOR linked list, the task is to pairwise swap the elements of the given XOR linked list . Examples: Input: 4 <-> 7 <-> 9 <-> 7Output: 7 <-> 4 <-> 7 <-> 9Explanation:First pair of nodes are swapped to formed the sequence {4, 7} and second pair of nodes are
12 min read
Update adjacent nodes if the current node is zero in a Singly Linked List Given a linked list. The task is to change the value of the previous and next node of a node to 0 if the current node is 0. Examples: Input : 2->3->4->5->0->9->0->9->NULL Output : 2->3->4->0->0->0->0->0->NULL Input : 0->2->3->4->0->0-
10 min read
Javascript Program For Pairwise Swapping Elements Of A Given Linked List By Changing Links Given a singly linked list, write a function to swap elements pairwise. For example, if the linked list is 1->2->3->4->5->6->7 then the function should change it to 2->1->4->3->6->5->7, and if the linked list is 1->2->3->4->5->6 then the function sh
4 min read