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
Insert a Node at the end of Doubly Linked List Given a Doubly Linked List, the task is to insert a new node at the end of the linked list.Examples: Input: Linked List = 1 <-> 2 <-> 3, NewNode = 4Output: Linked List = 1 <-> 2 <-> 3 <-> 4Input: Linked List = NULL, NewNode = 1Output: Linked List = 1Approach: Inserting
9 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
Delete a Doubly Linked List node at a given position Given a doubly linked list and a position pos, the task is to delete the node at the given position from the beginning of Doubly Linked List.Input: LinkedList: 1<->2<->3, pos = 2Output: LinkedList: 1<->3Input: LinkedList: 1<->2<->3, pos = 1Output: LinkedList: 2<->
9 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
Sorted insert in a doubly linked list with head and tail pointers A Doubly linked list is a linked list that consists of a set of sequentially linked records called nodes. Each node contains two fields that are references to the previous and to the next node in the sequence of nodes. The task is to create a doubly linked list by inserting nodes such that list rema
10 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
Delete all the even nodes from a Doubly Linked List Given a doubly linked list containing N nodes, the task is to delete all the even nodes from the list. Examples: Input: Initial List = 15 <=> 16 <=> 6 <=> 7 <=> 17 Output: Final List = 15 <=> 7 <=> 17Explanation: 16 and 6 are even nodes. So we need to delete them.
11 min read
Delete a Linked List node at a given position Given a singly linked list and a position (1-based indexing), the task is to delete a linked list node at the given position.Note: Position will be valid (i.e, 1 <= position <= linked list length)Example: Input: position = 2, Linked List = 8->2->3->1->7Output: Linked List = 8->3
8 min read