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

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

Python3

# Python3 implementation of above approach 
  
# Link list node  
class Node : 
    def __init__(self): 
        self.data = 0
        self.next = None
  
# Given a reference (pointer to pointer) 
# to the head of a list and an int, 
# appends a node at the end 
def append(head_ref, new_data): 
  
    # allocate node 
    new_node = Node() 
  
    last = head_ref 
  
    # put in the data 
    new_node.data = new_data 
  
    # This node is going to be 
    # the last node, so make next of 
    # it as None 
    new_node.next = None
  
    # If the Linked List is empty, 
    # then make the node as head 
    if (head_ref == None) : 
        head_ref = new_node 
        return head_ref 
      
    # Else traverse till the last node 
    while (last.next != None): 
        last = last.next
  
    # Change the next of last node 
    last.next = new_node 
    return head_ref 
  
def getFirstDuplicate(node): 
  
    # Unordered map to store the 
    # frequency of elements 
    mp = dict() 
    head = node 
  
    # update frequency of all the elements 
    while (node != None) : 
        mp[node.data] = mp.get(node.data, 0) + 1
        node = node.next
      
    node = head 
  
    # the first node from the left which 
    # appears more than once is the answer 
    while (node != None) : 
        if (mp[node.data] > 1): 
            return node.data 
        node = node.next
      
    # all the nodes are unique 
    return -1
  
# Driver code 
  
# Start with the empty list 
head = None
  
# Insert element 
head = append(head, 6) 
head = append(head, 2) 
head = append(head, 1) 
head = append(head, 6) 
head = append(head, 2) 
head = append(head, 1) 
  
print(getFirstDuplicate(head)) 
  
# This code is contributed by Arnab Kundu 

Output:

Time Complexity : O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

C++

Python3

Recommended Posts: