Swap given nodes in a Doubly Linked List without modifying data
Last Updated :
05 Jul, 2022
Given a doubly linked list having all unique elements and two keys X and Y, the task is to swap nodes for two given keys by changing links only.
Note: It may be considered that X and Y are always present in the list.
Examples:
Input: list = 1 <-> 8 <-> 7 <-> 9 <-> 4, X = 1, Y = 4
Output: 4 <-> 8 <-> 7 <-> 9 <-> 1
Input: list = 0 <-> 1, X = 0, Y = 1
Output: 1 <-> 0
Approach: The problem can be solved by traversing pointers to nodes having values X and Y and swap them.
Follow the steps mentioned below:
- Search X and Y in the given doubly linked list.
- After searching, swap the nodes by making the previous adjacent pointer of X to be previous adjacent pointer of Y and next adjacent pointer of X to be next adjacent pointer of Y and vice versa.
Below is the implementation of the above approach:
C++
// C++ code to implement the above approach
#include <bits/stdc++.h>
using namespace std;
// Link list Node Class
class Node {
public:
int data;
Node* prev;
Node* next;
// Constructor function
Node(int data)
{
this->data = data;
this->prev = NULL;
this->next = NULL;
}
};
// Function to print linked list
void print(Node* head)
{
Node* temp = head;
// Iterate until node is NOT NULL
while (temp != NULL) {
cout << temp->data << " ";
temp = temp->next;
}
cout << endl;
}
// Function to push a node in DLL
void push(Node*& head, Node*& tail,
int item)
{
// DLL is empty
if (tail == NULL) {
Node* temp = new Node(item);
tail = temp;
head = temp;
}
// DLL is not empty
else {
Node* temp = new Node(item);
tail->next = temp;
temp->prev = tail;
tail = temp;
}
}
// Function to find the nodes
// which have to be swapped
pair<Node*, Node*> find(Node*& head,
int x, int y)
{
Node* N1 = NULL;
Node* N2 = NULL;
Node* temp = head;
// Traversing the list
while (temp != NULL) {
if (temp->data == x)
N1 = temp;
else if (temp->data == y)
N2 = temp;
temp = temp->next;
}
return make_pair(N1, N2);
}
// Function to swap the nodes
// consisting of x and y
void swap(Node*& head, Node*& tail,
int x, int y)
{
// Edge Cases
if (head == NULL || head->next == NULL
|| x == y)
return;
// Finding the Nodes
pair<Node*, Node*> p = find(head, x, y);
Node* Node1 = p.first;
Node* Node2 = p.second;
if (Node1 == head)
head = Node2;
else if (Node2 == head)
head = Node1;
if (Node1 == tail)
tail = Node2;
else if (Node2 == tail)
tail = Node1;
// Swapping Node1 and Node2
Node* temp;
temp = Node1->next;
Node1->next = Node2->next;
Node2->next = temp;
if (Node1->next != NULL)
Node1->next->prev = Node1;
if (Node2->next != NULL)
Node2->next->prev = Node2;
temp = Node1->prev;
Node1->prev = Node2->prev;
Node2->prev = temp;
if (Node1->prev != NULL)
Node1->prev->next = Node1;
if (Node2->prev != NULL)
Node2->prev->next = Node2;
}
// Driver Code
int main()
{
Node* head = NULL;
Node* tail = NULL;
push(head, tail, 1);
push(head, tail, 8);
push(head, tail, 7);
push(head, tail, 9);
push(head, tail, 4);
int X = 1, Y = 4;
cout << "Before Swapping: ";
print(head);
swap(head, tail, X, Y);
cout << "After Swapping: ";
print(head);
return 0;
}
// Java code to implement the above approach
import java.util.*;
class GFG{
// Link list Node Class
static class Node {
int data;
Node prev;
Node next;
// Constructor function
Node(int data)
{
this.data = data;
this.prev = null;
this.next = null;
}
};
static class pair
{
Node first, second;
public pair(Node first, Node second)
{
this.first = first;
this.second = second;
}
}
// Function to print linked list
static void print(Node head)
{
Node temp = head;
// Iterate until node is NOT null
while (temp != null) {
System.out.print(temp.data+ " ");
temp = temp.next;
}
System.out.println();
}
static Node head;
static Node tail;
// Function to push a node in DLL
static void push( int item)
{
// DLL is empty
if (tail == null) {
Node temp = new Node(item);
tail = temp;
head = temp;
}
// DLL is not empty
else {
Node temp = new Node(item);
tail.next = temp;
temp.prev = tail;
tail = temp;
}
}
// Function to find the nodes
// which have to be swapped
static pair find(int x, int y)
{
Node N1 = null;
Node N2 = null;
Node temp = head;
// Traversing the list
while (temp != null) {
if (temp.data == x)
N1 = temp;
else if (temp.data == y)
N2 = temp;
temp = temp.next;
}
return new pair(N1, N2);
}
// Function to swap the nodes
// consisting of x and y
static void swap( int x, int y)
{
// Edge Cases
if (head == null || head.next == null
|| x == y)
return;
// Finding the Nodes
pair p = find( x, y);
Node Node1 = p.first;
Node Node2 = p.second;
if (Node1 == head)
head = Node2;
else if (Node2 == head)
head = Node1;
if (Node1 == tail)
tail = Node2;
else if (Node2 == tail)
tail = Node1;
// Swapping Node1 and Node2
Node temp;
temp = Node1.next;
Node1.next = Node2.next;
Node2.next = temp;
if (Node1.next != null)
Node1.next.prev = Node1;
if (Node2.next != null)
Node2.next.prev = Node2;
temp = Node1.prev;
Node1.prev = Node2.prev;
Node2.prev = temp;
if (Node1.prev != null)
Node1.prev.next = Node1;
if (Node2.prev != null)
Node2.prev.next = Node2;
}
// Driver Code
public static void main(String[] args)
{
head = null;
tail = null;
push( 1);
push( 8);
push(7);
push(9);
push( 4);
int X = 1, Y = 4;
System.out.print("Before Swapping: ");
print(head);
swap( X, Y);
System.out.print("After Swapping: ");
print(head);
}
}
// This code is contributed by shikhasingrajput
# Python code to implement the above approach
# Link list Node Class
class Node:
def __init__(self, data):
self.data = data
self.prev = None
self.next = None
class pair:
def __init__(self, first, second):
self.first = first
self.second = second
class DoublyLL:
def __init__(self):
self.head = None
self.tail = None
# Function to print linked list
def print_list(self):
temp = self.head
while temp:
print(temp.data, end=" ")
temp = temp.next
print()
# Function to push a node in DLL
def push(self, item):
# DLL is empty
if self.tail == None:
temp = Node(item)
self.tail = temp
self.head = temp
# DLL is not empty
else:
temp = Node(item)
self.tail.next = temp
temp.prev = self.tail
self.tail = temp
# Function to find the nodes
# which have to be swapped
def find(self, x, y):
N1 = None
N2 = None
temp = self.head
# Traversing the list
while temp != None:
if temp.data == x:
N1 = temp
elif temp.data == y:
N2 = temp
temp = temp.next
return pair(N1, N2)
# Function to swap the nodes
# consisting of x and y
def swap(self, x, y):
# Edge Cases
if self.head == None or self.head.next == None or x == y:
return
# Finding the Nodes
p = self.find(x, y)
Node1 = p.first
Node2 = p.second
if Node1 == self.head:
self.head = Node2
elif Node2 == self.head:
self.head = Node1
if Node1 == self.tail:
self.tail = Node2
elif Node2 == self.tail:
self.tail = Node1
# Swapping Node1 and Node2
temp = None
temp = Node1.next
Node1.next = Node2.next
Node2.next = temp
if Node1.next != None:
Node1.next.prev = Node1
if Node2.next != None:
Node2.next.prev = Node2
temp = Node1.prev
Node1.prev = Node2.prev
Node2.prev = temp
if Node1.prev != None:
Node1.prev.next = Node1
if Node2.prev != None:
Node2.prev.next = Node2
# Driver Code
if __name__ == '__main__':
dll = DoublyLL()
dll.push(1)
dll.push(8)
dll.push(7)
dll.push(9)
dll.push(4)
X = 1
Y = 4
print("Before Swapping:", end=" ")
dll.print_list()
dll.swap(X, Y)
print("After Swapping:", end=" ")
dll.print_list()
# This code is contributed by Tapesh (tapeshdua420)
// C# code to implement the above approach
using System;
public class GFG{
// Link list Node Class
class Node {
public int data;
public Node prev;
public Node next;
// Constructor function
public Node(int data)
{
this.data = data;
this.prev = null;
this.next = null;
}
};
class pair
{
public Node first, second;
public pair(Node first, Node second)
{
this.first = first;
this.second = second;
}
}
// Function to print linked list
static void print(Node head)
{
Node temp = head;
// Iterate until node is NOT null
while (temp != null) {
Console.Write(temp.data+ " ");
temp = temp.next;
}
Console.WriteLine();
}
static Node head;
static Node tail;
// Function to push a node in DLL
static void push( int item)
{
// DLL is empty
if (tail == null) {
Node temp = new Node(item);
tail = temp;
head = temp;
}
// DLL is not empty
else {
Node temp = new Node(item);
tail.next = temp;
temp.prev = tail;
tail = temp;
}
}
// Function to find the nodes
// which have to be swapped
static pair find(int x, int y)
{
Node N1 = null;
Node N2 = null;
Node temp = head;
// Traversing the list
while (temp != null) {
if (temp.data == x)
N1 = temp;
else if (temp.data == y)
N2 = temp;
temp = temp.next;
}
return new pair(N1, N2);
}
// Function to swap the nodes
// consisting of x and y
static void swap( int x, int y)
{
// Edge Cases
if (head == null || head.next == null
|| x == y)
return;
// Finding the Nodes
pair p = find( x, y);
Node Node1 = p.first;
Node Node2 = p.second;
if (Node1 == head)
head = Node2;
else if (Node2 == head)
head = Node1;
if (Node1 == tail)
tail = Node2;
else if (Node2 == tail)
tail = Node1;
// Swapping Node1 and Node2
Node temp;
temp = Node1.next;
Node1.next = Node2.next;
Node2.next = temp;
if (Node1.next != null)
Node1.next.prev = Node1;
if (Node2.next != null)
Node2.next.prev = Node2;
temp = Node1.prev;
Node1.prev = Node2.prev;
Node2.prev = temp;
if (Node1.prev != null)
Node1.prev.next = Node1;
if (Node2.prev != null)
Node2.prev.next = Node2;
}
// Driver Code
public static void Main(String[] args)
{
head = null;
tail = null;
push( 1);
push( 8);
push(7);
push(9);
push( 4);
int X = 1, Y = 4;
Console.Write("Before Swapping: ");
print(head);
swap( X, Y);
Console.Write("After Swapping: ");
print(head);
}
}
// This code contributed by shikhasingrajput
<script>
// JavaScript code to implement the above approach
// Link list Node Class
class Node{
constructor(data){
this.data = data
this.prev = null
this.next = null
}
}
class pair{
constructor(first, second){
this.first = first
this.second = second
}
}
class DoublyLL{
constructor(){
this.head = null
this.tail = null
}
// Function to print linked list
print_list(){
let temp = this.head
while(temp){
document.write(temp.data," ")
temp = temp.next
}
document.write("</br>")
}
// Function to push a node in DLL
push(item){
// DLL is empty
if(this.tail == null){
let temp = new Node(item)
this.tail = temp
this.head = temp
}
// DLL is not empty
else{
let temp = new Node(item)
this.tail.next = temp
temp.prev = this.tail
this.tail = temp
}
}
// Function to find the nodes
// which have to be swapped
find(x, y){
let N1 = null
let N2 = null
let temp = this.head
// Traversing the list
while(temp != null){
if(temp.data == x)
N1 = temp
else if(temp.data == y)
N2 = temp
temp = temp.next
}
return new pair(N1, N2)
}
// Function to swap the nodes
// consisting of x and y
swap(x, y){
// Edge Cases
if(this.head == null || this.head.next == null || x == y)
return
// Finding the Nodes
let p = this.find(x, y)
let Node1 = p.first
let Node2 = p.second
if(Node1 == this.head)
this.head = Node2
else if(Node2 == this.head)
this.head = Node1
if(Node1 == this.tail)
this.tail = Node2
else if(Node2 == this.tail)
this.tail = Node1
// Swapping Node1 and Node2
let temp = null
temp = Node1.next
Node1.next = Node2.next
Node2.next = temp
if(Node1.next != null)
Node1.next.prev = Node1
if(Node2.next != null)
Node2.next.prev = Node2
temp = Node1.prev
Node1.prev = Node2.prev
Node2.prev = temp
if(Node1.prev != null)
Node1.prev.next = Node1
if(Node2.prev != null)
Node2.prev.next = Node2
}
}
// Driver Code
let dll = new DoublyLL()
dll.push(1)
dll.push(8)
dll.push(7)
dll.push(9)
dll.push(4)
let X = 1
let Y = 4
document.write("Before Swapping:"," ")
dll.print_list()
dll.swap(X, Y)
document.write("After Swapping:"," ")
dll.print_list()
// This code is contributed by shinjanpatra
</script>
OutputBefore Swapping: 1 8 7 9 4
After Swapping: 4 8 7 9 1
Time Complexity: O(N)
Auxiliary Space: O(1)
Similar Reads
Sort given Binary Doubly Linked List without modifying the data Given a head and a tail of a doubly linked list containing 0s and 1s, the task is to sort the Doubly linked list without modifying the data. Examples: Input: head = 1->1->0->0->1->0->1->1->0->0->NULLOutput: 0->0->0->0->0->1->1->1->1->1->NUL
11 min read
Reverse a Doubly Linked List without swapping nodes Write a program to reverse the given Doubly Linked List. See below diagrams for example. (a) Original Doubly Linked List (b) Reversed Doubly Linked List Approach: In the previous post, doubly linked list is being reversed by swapping prev and next pointers for all nodes, changing prev of the head (o
10 min read
Insert a Node after a given node in Doubly Linked List Given a Doubly Linked List, the task is to insert a new node after a given node in the linked list.Examples: Input: Linked List = 1 <-> 2 <-> 4, newData = 3, key = 2Output: Linked List = 1 <-> 2 <-> 3 <-> 4Explanation: New node 3 is inserted after key, that is node 2.In
11 min read
Insert a Node before a given node in Doubly Linked List Given a Doubly Linked List, the task is to insert a new node before a given node in the linked list.Examples: Input: Linked List = 1 <-> 3 <-> 4, newData = 2, key = 3Output: Linked List = 1 <-> 2 <-> 3 <-> 4Explanation: New node with data 2 is inserted before the node w
12 min read
Swap Kth node from beginning with Kth node from end in a Doubly Linked List Prerequisites: Doubly Linked List Given a doubly-linked list, the task is to swap Kth node from the beginning with Kth node from the ending.Note: Please note here the nodes are swapped and not the data in the nodes. Examples: Input: DLL = 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6
15+ min read