Skip to content
Related Articles

Related Articles

Swap given nodes in a Doubly Linked List without modifying data

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 05 Jul, 2022
View Discussion
Improve Article
Save Article

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




// 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


Python3




# 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#




// 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


Javascript




<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>


 
 

Output

Before Swapping: 1 8 7 9 4 
After Swapping: 4 8 7 9 1 

 

Time Complexity: O(N)
Auxiliary Space: O(1)

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!