Find the first duplicate element in the linked list

Given a linked list. Find the first element from the left which appears more than once. If all the elements are unique then print -1.

Examples:

Input : 1 2 3 4 3 2 1
Output : 1
In this linked list the element 1 occurs two times
and it is the first element to satisfy the condition.
Hence the answer is 1.

Input : 1 2, 3, 4, 5
Output : -1
All the elements are unique. Hence the answer is -1.

Approach:

Count the frequency of all the elements of the linked list using a map.
Now, traverse the linked list again to find the first element from the left whose frequency is greater than 1.
If no such element exists then print -1.

Below is the implementation of the above approach:

// C++ implementation of the above approach 
#include <bits/stdc++.h> 
using namespace std; 
  
// A linked list node 
class Node { 
public: 
    int data; 
    Node* next; 
}; 
  
// Given a reference (pointer to pointer) 
// to the head of a list and an int, 
// appends a new node at the end 
void append(Node** head_ref, int new_data) 
{ 
    // allocate node 
    Node* new_node = new Node(); 
  
    Node* last = *head_ref; 
  
    // put in the data 
    new_node->data = new_data; 
  
    // This new node is going to be 
    // the last node, so make next of 
    // it as NULL 
    new_node->next = NULL; 
  
    // If the Linked List is empty, 
    // then make the new node as head 
    if (*head_ref == NULL) { 
        *head_ref = new_node; 
        return; 
    } 
  
    // Else traverse till the last node 
    while (last->next != NULL) 
        last = last->next; 
  
    // Change the next of last node 
    last->next = new_node; 
    return; 
} 
  
int getFirstDuplicate(Node* node) 
{ 
  
    // Unordered map to store the 
    // frequency of elements 
    unordered_map<int, int> mp; 
    Node* head = node; 
  
    // update frequency of all the elements 
    while (node != NULL) { 
        mp[node->data]++; 
        node = node->next; 
    } 
  
    node = head; 
  
    // the first node from the left which 
    // appears more than once is the answer 
  
    while (node != NULL) { 
        if (mp[node->data] > 1) 
            return node->data; 
        node = node->next; 
    } 
  
    // all the nodes are unique 
    return -1; 
} 
  
// driver code 
int main() 
{ 
    // Start with the empty list 
    Node* head = NULL; 
  
    // Insert element 
    append(&head, 6); 
    append(&head, 2); 
    append(&head, 1); 
    append(&head, 6); 
    append(&head, 2); 
    append(&head, 1); 
  
    cout << getFirstDuplicate(head); 
  
    return 0; 
} 

Output:

Time Complexity : O(N)

My Personal Notes

Suggest a Topic

Recommended Posts: