Skip to content
Related Articles

Related Articles

Find the first duplicate element in the linked list
  • Last Updated : 06 Nov, 2020

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


Java




// Java implementation of
// the above approach
import java.util.*;
class GFG{
 
// A linked list node
static class Node
{
  int data;
  Node next;
};
static Node head_ref;
   
// Given a reference (pointer to
// pointer) to the head of a list
// and an int, appends a new node
// at the end
static void append(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;
}
 
static int getFirstDuplicate(Node node)
{
  // Unordered map to store the
  // frequency of elements
  HashMap<Integer,
          Integer> mp = new HashMap<Integer,
                                    Integer>();
  Node head = node;
 
  // update frequency of all
  // the elements
  while (node != null)
  {
    if(mp.containsKey(node.data))
      mp.put(node.data,
             mp.get(node.data) + 1);
    else
      mp.put(node.data, 1);
 
    node = node.next;
  }
 
  node = head;
 
  // the first node from the
  // left which appears more
  // than once is the answer
  while (node != null)
  {
    if (mp.get(node.data) > 1)
      return node.data;
    node = node.next;
  }
 
  // all the nodes are unique
  return -1;
}
 
// Driver code
public static void main(String[] args)
{
  // Start with the empty list
  head_ref = null;
 
  // Insert element
  append(6);
  append(2);
  append(1);
  append(6);
  append(2);
  append(1);
 
  System.out.print(
         getFirstDuplicate(head_ref));
}
}
 
// This code is contributed by Rajput-Ji


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


C#




// C# implementation of
// the above approach
using System;
using System.Collections.Generic;
class GFG{
 
// A linked list node
public class Node
{
  public int data;
  public Node next;
};
   
static Node head_ref;
   
// Given a reference (pointer to
// pointer) to the head of a list
// and an int, appends a new node
// at the end
static void append(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;
}
 
static int getFirstDuplicate(Node node)
{
  // Unordered map to store the
  // frequency of elements
  Dictionary<int,
             int> mp =
             new Dictionary<int,
                            int>();
  Node head = node;
 
  // update frequency of all
  // the elements
  while (node != null)
  {
    if(mp.ContainsKey(node.data))
      mp[node.data]++;
             
    else
      mp.Add(node.data, 1);
 
    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
public static void Main(String[] args)
{
  // Start with the empty list
  head_ref = null;
 
  // Insert element
  append(6);
  append(2);
  append(1);
  append(6);
  append(2);
  append(1);
 
  Console.Write(
  getFirstDuplicate(head_ref));
}
}
 
// This code is contributed by 29AjayKumar


Output: 

6






 

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 arrow_drop_up
Recommended Articles
Page :