Remove duplicates from an unsorted doubly linked list

3.3

Given an unsorted doubly linked list containing n nodes. The problem is to remove duplicate nodes from the given list.

Examples:

Method 1 (Naive Approach):
This is the simplest way where two loops are used. Outer loop is used to pick the elements one by one and inner loop compares the picked element with rest of the elements.

// C++ implementation to remove duplicates from an
// unsorted doubly linked list
#include <bits/stdc++.h>

using namespace std;

// a node of the doubly linked list
struct Node {
    int data;
    struct Node* next;
    struct Node* prev;
};

// Function to delete a node in a Doubly Linked List.
// head_ref --> pointer to head node pointer.
// del  -->  pointer to node to be deleted.
void deleteNode(struct Node** head_ref, struct Node* del)
{
    // base case
    if (*head_ref == NULL || del == NULL)
        return;

    // If node to be deleted is head node
    if (*head_ref == del)
        *head_ref = del->next;

    // Change next only if node to be deleted
    // is NOT the last node
    if (del->next != NULL)
        del->next->prev = del->prev;

    // Change prev only if node to be deleted
    // is NOT the first node
    if (del->prev != NULL)
        del->prev->next = del->next;

    // Finally, free the memory occupied by del
    free(del);
}

// function to remove duplicates from
// an unsorted doubly linked list
void removeDuplicates(struct Node** head_ref)
{
    // if DLL is empty or if it contains only
    // a single node
    if ((*head_ref) == NULL || 
        (*head_ref)->next == NULL)
        return;

    struct Node* ptr1, *ptr2;

    // pick elements one by one
    for (ptr1 = *head_ref; ptr1 != NULL; ptr1 = ptr1->next) {
        ptr2 = ptr1->next;

        // Compare the picked element with the
        // rest of the elements
        while (ptr2 != NULL) {

            // if duplicate, then delete it
            if (ptr1->data == ptr2->data) {

                // store pointer to the node next to 'ptr2'
                struct Node* next = ptr2->next;

                // delete node pointed to by 'ptr2'
                deleteNode(head_ref, ptr2);

                // update 'ptr2'
                ptr2 = next;
            }

            // else simply move to the next node
            else
                ptr2 = ptr2->next;
        }
    }
}

// Function to insert a node at the beginning
// of the Doubly Linked List
void push(struct Node** head_ref, int new_data)
{
    // allocate node
    struct Node* new_node = 
        (struct Node*)malloc(sizeof(struct Node));

    // put in the data
    new_node->data = new_data;

    // since we are adding at the begining,
    // prev is always NULL
    new_node->prev = NULL;

    // link the old list off the new node
    new_node->next = (*head_ref);

    // change prev of head node to new node
    if ((*head_ref) != NULL)
        (*head_ref)->prev = new_node;

    // move the head to point to the new node
    (*head_ref) = new_node;
}

// Function to print nodes in a given doubly 
// linked list
void printList(struct Node* head)
{
    // if list is empty
    if (head == NULL)
        cout << "Doubly Linked list empty";

    while (head != NULL) {
        cout << head->data << " ";
        head = head->next;
    }
}

// Driver program to test above
int main()
{
    struct Node* head = NULL;

    // Create the doubly linked list:
    // 8<->4<->4<->6<->4<->8<->4<->10<->12<->12
    push(&head, 12);
    push(&head, 12);
    push(&head, 10);
    push(&head, 4);
    push(&head, 8);
    push(&head, 4);
    push(&head, 6);
    push(&head, 4);
    push(&head, 4);
    push(&head, 8);

    cout << "Original Doubly linked list:n";
    printList(head);

    /* remove duplicate nodes */
    removeDuplicates(&head);

    cout << "\nDoubly linked list after "
            "removing duplicates:n";
    printList(head);

    return 0;
}

Output:

Original Doubly linked list:
8 4 4 6 4 8 4 10 12 12
Doubly linked list after removing duplicates:
8 4 6 10 12

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

Method 2 (Sorting): Following are the steps:

  1. Sort the elements of the doubly linked list using Merge Sort. Refer this post.
  2. Remove duplicates in linear time using the algorithm to remove duplicates from a sorted doubly linked list.

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

Note that this method doesn’t preserve the original order of elements.

Method 3 Efficient Approach(Hashing):
We traverse the doubly linked list from head to end. For every newly encountered element, we check whether it is in the hash table: if yes, we remove it; otherwise we put it in the hash table. Hash table is implemented using unordered_set in C++.

// C++ implementation to remove duplicates from an
// unsorted doubly linked list
#include <bits/stdc++.h>

using namespace std;

// a node of the doubly linked list
struct Node {
    int data;
    struct Node* next;
    struct Node* prev;
};

// Function to delete a node in a Doubly Linked List.
// head_ref --> pointer to head node pointer.
// del  -->  pointer to node to be deleted.
void deleteNode(struct Node** head_ref, struct Node* del)
{
    // base case
    if (*head_ref == NULL || del == NULL)
        return;

    // If node to be deleted is head node
    if (*head_ref == del)
        *head_ref = del->next;

    // Change next only if node to be deleted 
    // is NOT the last node
    if (del->next != NULL)
        del->next->prev = del->prev;

    // Change prev only if node to be deleted 
    // is NOT the first node
    if (del->prev != NULL)
        del->prev->next = del->next;

    // Finally, free the memory occupied by del
    free(del);
}

// function to remove duplicates from
// an unsorted doubly linked list
void removeDuplicates(struct Node** head_ref)
{
    // if doubly linked list is empty
    if ((*head_ref) == NULL)
        return;

    // unordered_set 'us' implemented as hash table
    unordered_set<int> us;

    struct Node* current = *head_ref, *next;

    // traverse up to the end of the list
    while (current != NULL) {

        // if current data is seen before
        if (us.find(current->data) != us.end()) {

            // store pointer to the node next to 
            // 'current' node
            next = current->next;

            // delete the node pointed to by 'current'
            deleteNode(head_ref, current);

            // update 'current'
            current = next;
        }

        else {

            // insert the current data in 'us'
            us.insert(current->data);

            // move to the next node
            current = current->next;
        }
    }
}

// Function to insert a node at the beginning
// of the Doubly Linked List
void push(struct Node** head_ref, int new_data)
{
    // allocate node
    struct Node* new_node = 
         (struct Node*)malloc(sizeof(struct Node));

    // put in the data
    new_node->data = new_data;

    // since we are adding at the beginning,
    // prev is always NULL
    new_node->prev = NULL;

    // link the old list off the new node
    new_node->next = (*head_ref);

    // change prev of head node to new node
    if ((*head_ref) != NULL)
        (*head_ref)->prev = new_node;

    // move the head to point to the new node
    (*head_ref) = new_node;
}

// Function to print nodes in a given doubly 
// linked list
void printList(struct Node* head)
{
    // if list is empty
    if (head == NULL)
        cout << "Doubly Linked list empty";

    while (head != NULL) {
        cout << head->data << " ";
        head = head->next;
    }
}

// Driver program to test above
int main()
{
    struct Node* head = NULL;

    // Create the doubly linked list:
    // 8<->4<->4<->6<->4<->8<->4<->10<->12<->12
    push(&head, 12);
    push(&head, 12);
    push(&head, 10);
    push(&head, 4);
    push(&head, 8);
    push(&head, 4);
    push(&head, 6);
    push(&head, 4);
    push(&head, 4);
    push(&head, 8);

    cout << "Original Doubly linked list:n";
    printList(head);

    /* remove duplicate nodes */
    removeDuplicates(&head);

    cout << "\nDoubly linked list after "
             "removing duplicates:n";
    printList(head);

    return 0;
}

Output:

Original Doubly linked list:
8 4 4 6 4 8 4 10 12 12
Doubly linked list after removing duplicates:
8 4 6 10 12

Time Complexity: O(n)
Auxiliary Space: O(n)

This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

GATE CS Corner    Company Wise Coding Practice

Recommended Posts:



3.3 Average Difficulty : 3.3/5.0
Based on 3 vote(s)










Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share the link here.