Remove duplicates from an unsorted doubly linked list

Last Updated : 28 Aug, 2024

Given an unsorted doubly linked list containing n nodes, the task is to remove duplicate nodes while preserving the original order.

Examples: 

Input: Doubly Linked List = 1 <-> 2 <-> 3 <-> 2 <-> 4
Output: Doubly Linked List = 1 <-> 2 <-> 3 <-> 4

Remove-duplicates-from-a-sorted-linked-list
Removal of duplicate node 2 from Doubly Linked List

Input: Doubly Linked List = 8 <-> 4 <-> 4 <-> 6 <-> 4 <-> 8 <-> 4 <-> 10 <-> 12 <-> 12
Output: Doubly Linked List = 8 <-> 4 <-> 6 <-> 10 <-> 12

Table of Content

[Naive Approach] Using Nested Loops - O(n^2) Time and O(1) Space

The idea is to use two nested loops. The outer loop is used to pick the elements one by one and the inner loop compares the picked element with the rest of the elements in the doubly linked list. 

Below is the implementation of the above approach:

C++ 
// C++ program to remove duplicates from an 
// unsorted doubly linked list

#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;
  	Node* prev;

    Node(int val) {
        data = val;
        next = nullptr;
        prev = nullptr;
    }
};

// Function to remove duplicates using nested loops
Node* removeDuplicates(Node* head) {
    Node* curr = head; 

    // Traverse each node in the list
    while (curr != nullptr) {
        Node* temp = curr; 

        // Traverse the remaining nodes to find and 
        // remove duplicates
        while (temp->next != nullptr) {
            
            // Check if the next node has the same 
            // data as the current node
            if (temp->next->data == curr->data) {
                
                // Duplicate found, remove it
                Node* duplicate = temp->next;  
                temp->next = temp->next->next;  

                // Update the previous pointer of the
                // next node, if it exists
                if (temp->next != nullptr)
                    temp->next->prev = temp;

                // Free the memory of the duplicate node
                delete duplicate;
            } 
          	else {
              
              	// If the next node has different data from 
              	// the current node, move to the next node
                temp = temp->next;
            }
        }
        
        // Move to the next node in the list
        curr = curr->next;
    }
    return head;
}

void printList(Node* head) {
    Node* curr = head;
    while (curr != nullptr) {
        cout << curr->data << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {
    
    // Create a doubly linked list:
    // 1 <-> 2 <-> 3 <-> 2 <-> 4
    Node* head = new Node(1);
    head->next = new Node(2);
    head->next->prev = head;
    head->next->next = new Node(3);
    head->next->next->prev = head->next;
    head->next->next->next = new Node(2);
    head->next->next->next->prev = head->next->next;
    head->next->next->next->next = new Node(4);
    head->next->next->next->next->prev = head->next->next->next;

    head = removeDuplicates(head);
  
    printList(head);

    return 0;
}
C 
// C program to remove duplicates
// from an unsorted doubly linked list

#include <stdio.h>

struct Node {
    int data;
    struct Node *next;
    struct Node *prev;
};

// Function to remove duplicates using nested loops
struct Node *removeDuplicates(struct Node *head) {
    struct Node *curr = head;

    // Traverse each node in the list
    while (curr != NULL) {
        struct Node *temp = curr;

        // Traverse the remaining nodes to
        // find and remove duplicates
        while (temp->next != NULL) {

            // Check if the next node has the same
            // data as the current node
            if (temp->next->data == curr->data) {
              
                // Duplicate found, remove it
                struct Node *duplicate = temp->next;
                temp->next = temp->next->next;

                // Update the previous pointer of the next
                // node, if it exists
                if (temp->next != NULL)
                    temp->next->prev = temp;

                // Free the memory of the duplicate node
                free(duplicate);
            }
            else {
              
              	// If the next node has different data from 
              	// the current node, move to the next node
                temp = temp->next;
            }
        }

        // Move to the next node in the list
        curr = curr->next;
    }
    return head;
}

void printList(struct Node *head) {
    struct Node *curr = head;
    while (curr != NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

struct Node *createNode(int val) {
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    newNode->data = val;
    newNode->next = NULL;
    newNode->prev = NULL;
    return newNode;
}

int main() {
  
    // Create a doubly linked list:
    // 1 <-> 2 <-> 3 <-> 2 <-> 4
    struct Node *head = createNode(1);
    head->next = createNode(2);
    head->next->prev = head;
    head->next->next = createNode(3);
    head->next->next->prev = head->next;
    head->next->next->next = createNode(2);
    head->next->next->next->prev = head->next->next;
    head->next->next->next->next = createNode(4);
    head->next->next->next->next->prev = head->next->next->next;

    head = removeDuplicates(head);

    printList(head);

    return 0;
}
Java 
// Java program to remove duplicates from
// an unsorted doubly linked list

class Node {
    int data;
    Node next;
    Node prev;

    Node(int val) {
        data = val;
        next = null;
        prev = null;
    }
}

class GfG {
    static Node removeDuplicates(Node head) {
        Node curr = head;

        // Traverse each node in the list
        while (curr != null) {
            Node temp = curr;

            // Traverse the remaining nodes to
            // find and remove duplicates
            while (temp.next != null) {

                // Check if the next node has the same data
                // as the current node
                if (temp.next.data == curr.data) {

                    // Duplicate found, remove it
                    Node duplicate = temp.next;
                    temp.next = temp.next.next;

                    // Update the previous pointer of the
                    // next node, if it exists
                    if (temp.next != null)
                        temp.next.prev = temp;

                    // Free the memory of the duplicate node
                    duplicate = null;
                } 
              	else {
                  
                  	// If the next node has different data from 
              		// the current node, move to the next node
                    temp = temp.next;
                }
            }
            // Move to the next node in the list
            curr = curr.next;
        }
        return head;
    }
  
  	static void printList(Node head) {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data + " ");
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
      
        // Create a doubly linked list:
     	// 1 <-> 2 <-> 3 <-> 2 <-> 4
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.prev = head;
        head.next.next = new Node(3);
        head.next.next.prev = head.next;
        head.next.next.next = new Node(2);
        head.next.next.next.prev = head.next.next;
        head.next.next.next.next = new Node(4);
        head.next.next.next.next.prev = head.next.next.next;

        head = removeDuplicates(head);

        printList(head);
    }
}
Python 
# Python program to remove duplicates
# from an unsorted doubly linked list

class Node:
    def __init__(self, val):
        self.data = val
        self.next = None
        self.prev = None

def print_list(head):
    curr = head
    while curr is not None:
        print(curr.data, end=" ")
        curr = curr.next
    print()

def remove_duplicates(head):
    curr = head  

    # Traverse each node in the list
    while curr is not None:
        temp = curr 

        # Traverse the remaining nodes to 
        # find and remove duplicates
        while temp.next is not None:
            
            # Check if the next node has the same 
            # data as the curr node
            if temp.next.data == curr.data:
                
                # Duplicate found, remove it
                duplicate = temp.next  
                temp.next = temp.next.next  

                # Update the previous pointer of
                # the next node, if it exists
                if temp.next is not None:
                    temp.next.prev = temp

                # Free the memory of the duplicate node
                del duplicate
            else:
              	
              	# If the next node has different data from 
              	# the current node, move to the next node
                temp = temp.next
        # Move to the next node in the list
        curr = curr.next
    return head
  
if __name__ == "__main__":
  
    # Create a doubly linked list:
    # 1 <-> 2 <-> 3 <-> 2 <-> 4
    head = Node(1)
    head.next = Node(2)
    head.next.prev = head
    head.next.next = Node(3)
    head.next.next.prev = head.next
    head.next.next.next = Node(2)
    head.next.next.next.prev = head.next.next
    head.next.next.next.next = Node(4)
    head.next.next.next.next.prev = head.next.next.next

    head = remove_duplicates(head)
    
    print_list(head)
C# 
// C# program to remove duplicates from an unsorted
// doubly linked list

using System;

class Node {
    public int Data;
    public Node Next;
    public Node Prev;

    public Node(int val) {
        Data = val;
        Next = null;
        Prev = null;
    }
}

class GfG {
    static void PrintList(Node head) {
        Node curr = head;
        while (curr != null) {
            Console.Write(curr.Data + " ");
            curr = curr.Next;
        }
        Console.WriteLine();
    }

    static Node RemoveDuplicates(Node head) {
        Node curr = head;

        // Traverse each node in the list
        while (curr != null) {
            Node temp = curr;

            // Traverse the remaining nodes to
            // find and remove duplicates
            while (temp.Next != null) {

                // Check if the next node has the same data
                // as the curr node
                if (temp.Next.Data == curr.Data) {
                  
                    // Duplicate found, remove it
                    temp.Next = temp.Next.Next;

                    // Update the previous pointer of the
                    // next node, if it exists
                    if (temp.Next != null) {
                        temp.Next.Prev = temp;
                    }
                }
                else {

                    // If the next node has different data from 
              		// the current node, move to the next node
                    temp = temp.Next;
                }
            }
            // Move to the next node in the list
            curr = curr.Next;
        }
        return head;
    }

    static void Main() {
      
        // Create a doubly linked list: 
      	// 1 <-> 2 <-> 3 <-> 2 <-> 4
        Node head = new Node(1);
        head.Next = new Node(2);
        head.Next.Prev = head;
        head.Next.Next = new Node(3);
        head.Next.Next.Prev = head.Next;
        head.Next.Next.Next = new Node(2);
        head.Next.Next.Next.Prev = head.Next.Next;
        head.Next.Next.Next.Next = new Node(4);
        head.Next.Next.Next.Next.Prev = head.Next.Next.Next;

        head = RemoveDuplicates(head);

        PrintList(head);
    }
}
JavaScript 
// Javascript program to remove duplicates from
// an unsorted doubly linked list

class Node {
    constructor(val) {
        this.data = val;
        this.next = null;
        this.prev = null;
    }
}

function printList(head) {
    let curr = head;
    while (curr !== null) {
        console.log(curr.data + " ");
        curr = curr.next;
    }
    console.log();
}

function removeDuplicates(head) {
    let curr = head;

    // Traverse each node in the list
    while (curr !== null) {
        let temp = curr;

        // Traverse the remaining nodes to find and remove
        // duplicates
        while (temp.next !== null) {

            // Check if the next node has the same data as
            // the curr node
            if (temp.next.data === curr.data) {

                // Duplicate found, remove it
                let duplicate = temp.next;
                temp.next = temp.next.next;

                // Update the previous pointer of the next
                // node, if it exists
                if (temp.next !== null) {
                    temp.next.prev = temp;
                }

                // Free the memory of the duplicate node
                delete duplicate;
            }
            else {

                // If the next node has different data from 
              	// the current node, move to the next node
                temp = temp.next;
            }
        }
        // Move to the next node in the list
        curr = curr.next;
    }
    return head;
}

// Create a doubly linked list:
// 1 <-> 2 <-> 3 <-> 2 <-> 4
let head = new Node(1);
head.next = new Node(2);
head.next.prev = head;
head.next.next = new Node(3);
head.next.next.prev = head.next;
head.next.next.next = new Node(2);
head.next.next.next.prev = head.next.next;
head.next.next.next.next = new Node(4);
head.next.next.next.next.prev = head.next.next.next;

head = removeDuplicates(head);

printList(head);

Output
1 2 3 4

Time Complexity: O(n^2), Two nested loops are used to find the duplicates.
Auxiliary Space: O(1)

[Expected Approach] Using HashSet - O(n) Time and O(n) Space

The idea is to traverse the doubly linked list from head to end. For every newly encountered element

  • If the element is already present in the HashSet, remove it from the list.
  • If the element is not in the HashSet, add it to the HashSet and move ahead in the list.

Step-by-step implementation:

  • Create a hash set for keeping track of data nodes.
  • Start traversing from the head of the list.
  • For each node check if node’s data is in the set:
    • If present, update pointers to remove the node and delete the node.
    • If not present then add the data into the set.

Below is the implementation of the above approach:

C++ 
// C++ implementation to remove duplicates from
// an unsorted doubly linked list using hashing

#include <iostream>
#include <unordered_set>
using namespace std;

class Node {
  public:
    int data;
    Node *next;
    Node *prev;

    Node(int x) {
        data = x;
        prev = nullptr;
        next = nullptr;
    }
};

Node *removeDuplicates(Node *head) {
    unordered_set<int> hashSet;
    Node *curr = head;

    while (curr != nullptr) {

        // Check if the element is already in the hash table
        if (hashSet.find(curr->data) != hashSet.end()) {

            // Element is present, remove it
            // Adjust previous node's next pointer
            if (curr->prev)
                curr->prev->next = curr->next;

            // Adjust next node's prev pointer
            if (curr->next)
                curr->next->prev = curr->prev;

            // Delete the curr node
            Node *temp = curr;
            curr = curr->next;
            delete temp;
        }
        else {

            // Element is not present, add it to hash table
            hashSet.insert(curr->data);
            curr = curr->next;
        }
    }
    return head;
}

void printList(Node *head) {
  	Node *curr = head;
    while (curr != nullptr) {
        cout << curr->data << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {
  
    // Create a doubly linked list:
  	// 1 <-> 2 <-> 3 <-> 2 <-> 4
    Node *head = new Node(1);
    head->next = new Node(2);
    head->next->prev = head;
    head->next->next = new Node(3);
    head->next->next->prev = head->next;
    head->next->next->next = new Node(2);
    head->next->next->next->prev = head->next->next;
    head->next->next->next->next = new Node(4);
    head->next->next->next->next->prev = head->next->next->next;

    head = removeDuplicates(head);

    printList(head);

    return 0;
}
Java 
// Java implementation to remove duplicates from
// an unsorted doubly linked list using hashing

import java.util.HashSet;

class Node {
    int data;
    Node next;
    Node prev;

    Node(int x) {
        data = x;
        next = null;
        prev = null;
    }
}

class GfG {
    static Node removeDuplicates(Node head) {
        HashSet<Integer> hashSet = new HashSet<>();
        Node curr = head;

        while (curr != null) {

            // Check if the element is already in the hash
            // table
            if (hashSet.contains(curr.data)) {

                // Element is present, remove it
                // Adjust previous node's next pointer
                if (curr.prev != null)
                    curr.prev.next = curr.next;

                // Adjust next node's prev pointer
                if (curr.next != null)
                    curr.next.prev = curr.prev;

                // Delete the curr node
                Node temp = curr;
                curr = curr.next;
                temp = null;
            }
            else {

                // Element is not present, add it to hash
                // table
                hashSet.add(curr.data);
                curr = curr.next;
            }
        }
        return head;
    }

    static void printList(Node head) {
      	Node curr = head;
        while (curr != null) {
            System.out.print(curr.data + " ");
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
      
        // Create a doubly linked list:
      	// 1 <-> 2 <-> 3 <-> 2 <-> 4
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.prev = head;
        head.next.next = new Node(3);
        head.next.next.prev = head.next;
        head.next.next.next = new Node(2);
        head.next.next.next.prev = head.next.next;
        head.next.next.next.next = new Node(4);
        head.next.next.next.next.prev = head.next.next.next;

        head = removeDuplicates(head);

        printList(head);
    }
}
Python 
# Python implementation to remove duplicates
# from an unsorted doubly linked list using hashing

class Node:
    def __init__(self, x):
        self.data = x
        self.next = None
        self.prev = None


def remove_duplicates(head):
    hash_set = set()
    curr = head

    while curr is not None:

        # Check if the element is already in the hash table
        if curr.data in hash_set:

            # Element is present, remove it
            # Adjust previous node's next pointer
            if curr.prev:
                curr.prev.next = curr.next

            # Adjust next node's prev pointer
            if curr.next:
                curr.next.prev = curr.prev

            # Delete the curr node
            temp = curr
            curr = curr.next
            del temp
        else:

            # Element is not present, add it to hash table
            hash_set.add(curr.data)
            curr = curr.next
    return head


def print_list(head):
    curr = head
    while curr is not None:
        print(curr.data, end=" ")
        curr = curr.next
    print()

if __name__ == "__main__":

    # Create a doubly linked list: 
    # 1 <-> 2 <-> 3 <-> 2 <-> 4
    head = Node(1)
    head.next = Node(2)
    head.next.prev = head
    head.next.next = Node(3)
    head.next.next.prev = head.next
    head.next.next.next = Node(2)
    head.next.next.next.prev = head.next.next
    head.next.next.next.next = Node(4)
    head.next.next.next.next.prev = head.next.next.next

    head = remove_duplicates(head)
    
    print_list(head)
C# 
// C# implementation to remove duplicates from 
// an unsorted doubly linked list using hashing

using System;
using System.Collections.Generic;

class Node {
    public int Data;
    public Node Next;
    public Node Prev;

    public Node(int x) {
        Data = x;
        Next = null;
        Prev = null;
    }
}

class GfG {
    static Node RemoveDuplicates(Node head) {
        HashSet<int> hashSet = new HashSet<int>();
        Node curr = head;

        while (curr != null) {

            // Check if the element is already in the hash table
            if (hashSet.Contains(curr.Data)) {

                // Element is present, remove it
                // Adjust previous node's next pointer
                if (curr.Prev != null)
                    curr.Prev.Next = curr.Next;
    

                // Adjust next node's prev pointer
                if (curr.Next != null)
                    curr.Next.Prev = curr.Prev;

                // Delete the current node
                curr = curr.Next;
            }
            else {

                // Element is not present, add it to hash table
                hashSet.Add(curr.Data);
                curr = curr.Next;
            }
        }
        return head;
    }

    static void PrintList(Node head) {
      	Node curr = head;
        while (curr != null) {
            Console.Write(curr.Data + " ");
            curr = curr.Next;
        }
        Console.WriteLine();
    }

    static void Main() {
      
        // Create a doubly linked list: 
        // 1 <-> 2 <-> 3 <-> 2 <-> 4
        Node head = new Node(1);
        head.Next = new Node(2);
        head.Next.Prev = head;
        head.Next.Next = new Node(3);
        head.Next.Next.Prev = head.Next;
        head.Next.Next.Next = new Node(2);
        head.Next.Next.Next.Prev = head.Next.Next;
        head.Next.Next.Next.Next = new Node(4);
        head.Next.Next.Next.Next.Prev = head.Next.Next.Next;

        head = RemoveDuplicates(head);

        PrintList(head);
    }
}
JavaScript 
// Javascript implementation to remove duplicates
// from an unsorted doubly linked list using hashing

class Node {
    constructor(x) {
        this.data = x;
        this.next = null;
        this.prev = null;
    }
}

function removeDuplicates(head) {
    const hashSet = new Set();
    let curr = head;

    while (curr !== null) {

        // Check if the element is already in the hash table
        if (hashSet.has(curr.data)) {

            // Element is present, remove it
            // Adjust previous node's next pointer
            if (curr.prev)
                curr.prev.next = curr.next;

            // Adjust next node's prev pointer
            if (curr.next)
                curr.next.prev = curr.prev;

            // Delete the curr node
            let temp = curr;
            curr = curr.next;
            temp = null; 
        }
        else {

            // Element is not present, add it to hash table
            hashSet.add(curr.data);
            curr = curr.next;
        }
    }
    return head;
}

function printList(head) {
    let curr = head;
    while (curr !== null) {
        console.log(curr.data + " ");
        curr = curr.next;
    }
    console.log();
}

// Create a doubly linked list:
// 1 <-> 2 <-> 3 <-> 2 <-> 4
let head = new Node(1);
head.next = new Node(2);
head.next.prev = head;
head.next.next = new Node(3);
head.next.next.prev = head.next;
head.next.next.next = new Node(2);
head.next.next.next.prev = head.next.next;
head.next.next.next.next = new Node(4);
head.next.next.next.next.prev = head.next.next.next;

head = removeDuplicates(head);

printList(head);

Output
1 2 3 4

Time Complexity: O(n) , where n are the number of nodes in the doubly linked list.
Auxiliary Space: O(n)

Comment
Article Tags:
Linked List
DSA
doubly linked list

Explore