# Replace nodes with duplicates in linked list

• Difficulty Level : Medium
• Last Updated : 24 Jun, 2021

Given a linked list that contains some random integers from 1 to n with many duplicates. Replace each duplicate element that is present in the linked list with the values n+1, n+2, n+3 and so on(starting from left to right in the given linked list).

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

```Input : 1 3 1 4 4 2 1
Output : 1 3 5 4 6 2 7
Replace 2nd occurrence of 1 with 5 i.e. (4+1)
2nd occurrence of 4 with 6 i.e. (4+2)
3rd occurrence of 1 with 7 i.e. (4+3)

Input : 1 1 1 4 3 2 2
Output : 1 5 6 4 3 2 7```

Approach :
1. Traverse the linked list, store the frequencies of every number present in linked list in a map and alongwith it find the maximum integer present in linked list i.e. maxNum
2. Now, traverse the linked list again and if the frequency of any number is more than 1, set its value to -1 in map on its first occurrence.
3.The reason for this is that on next occurrence of this number we will find its value -1 which means this number has occurred before, change its data with maxNum + 1 and increment maxNum.

Below is the implementation of idea.

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `/* A linked list node */``struct` `Node {``    ``int` `data;``    ``struct` `Node* next;``};` `// Utility function to create a new Node``struct` `Node* newNode(``int` `data)``{``    ``Node* temp = ``new` `Node;``    ``temp->data = data;``    ``temp->next = NULL;``    ``return` `temp;``}` `// Function to replace duplicates from a``// linked list``void` `replaceDuplicates(``struct` `Node* head)``{``    ``// map to store the frequency of numbers``    ``unordered_map<``int``, ``int``> mymap;` `    ``Node* temp = head;` `    ``// variable to store the maximum number``    ``// in linked list``    ``int` `maxNum = 0;` `    ``// traverse the linked list to store``    ``// the frequency of every number and``    ``// find the maximum integer``    ``while` `(temp) {``        ``mymap[temp->data]++;``        ``if` `(maxNum < temp->data)``            ``maxNum = temp->data;``        ``temp = temp->next;``    ``}` `    ``// Traverse again the linked list``    ``while` `(head) {``    ` `        ``// Mark the node with frequency more``        ``// than 1 so that we can change the``        ``// 2nd occurrence of that number``        ``if` `(mymap[head->data] > 1)``            ``mymap[head->data] = -1;` `        ``// -1 means number has occurred``        ``// before change its value``        ``else` `if` `(mymap[head->data] == -1)``            ``head->data = ++maxNum;` `        ``head = head->next;``    ``}``}` `/* Function to print nodes in a given``linked list */``void` `printList(``struct` `Node* node)``{``    ``while` `(node != NULL) {``        ``printf``(``"%d "``, node->data);``        ``node = node->next;``    ``}``    ``cout << endl;``}` `/* Driver program to test above function */``int` `main()``{``    ``/* The constructed linked list is:``    ``1->3->1->4->4->2->1*/``    ``struct` `Node* head = newNode(1);``    ``head->next = newNode(3);``    ``head->next->next = newNode(1);``    ``head->next->next->next = newNode(4);``    ``head->next->next->next->next =``                                ``newNode(4);``    ``head->next->next->next->next->``                         ``next = newNode(2);``    ``head->next->next->next->next->``                   ``next->next = newNode(1);` `    ``cout << ``"Linked list before replacing"``         ``<< ``" duplicates\n"``;``    ``printList(head);` `    ``replaceDuplicates(head);` `    ``cout << ``"Linked list after replacing"``         ``<< ``" duplicates\n"``;``    ``printList(head);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{``    ` `// Representation of node``static` `class` `Node``{``    ``int` `data;``    ``Node next;``    ``Node(``int` `d)``    ``{``        ``data = d;``        ``next = ``null``;``    ``}``};`  `// Function to insert a node at the beginning``static` `Node insert(Node head, ``int` `item)``{``    ``Node temp = ``new` `Node(``0``);``    ``temp.data = item;``    ``temp.next = head;``    ``head = temp;``    ``return` `head;``}` `// Function to replace duplicates from a``// linked list``static` `void` `replaceDuplicates( Node head)``{``    ``// map to store the frequency of numbers``    ``Map mymap = ``new` `HashMap<>();` `    ``Node temp = head;` `    ``// variable to store the maximum number``    ``// in linked list``    ``int` `maxNum = ``0``;` `    ``// traverse the linked list to store``    ``// the frequency of every number and``    ``// find the maximum integer``    ``while` `(temp != ``null``)``    ``{``        ``mymap.put(temp.data,(mymap.get(temp.data) ==``                    ``null``?``0``:mymap.get(temp.data))+``1``);``        ``if` `(maxNum < temp.data)``            ``maxNum = temp.data;``        ``temp = temp.next;``    ``}` `    ``// Traverse again the linked list``    ``while` `(head != ``null``)``    ``{``    ` `        ``// Mark the node with frequency more``        ``// than 1 so that we can change the``        ``// 2nd occurrence of that number``        ``if` `(mymap.get(head.data) > ``1``)``            ``mymap.put(head.data, -``1``);` `        ``// -1 means number has occurred``        ``// before change its value``        ``else` `if` `(mymap.get(head.data) == -``1``)``            ``head.data = ++maxNum;` `        ``head = head.next;``    ``}``}` `// Function to print nodes in a given``//linked list /``static` `void` `printList( Node node)``{``    ``while` `(node != ``null``)``    ``{``        ``System.out.printf(``"%d "``, node.data);``        ``node = node.next;``    ``} System.out.println();``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ``// The constructed linked list is:``    ``// 1->3->1->4->4->2->1/``    ``Node head = ``new` `Node(``1``);``    ``head.next = ``new` `Node(``3``);``    ``head.next.next = ``new` `Node(``1``);``    ``head.next.next.next = ``new` `Node(``4``);``    ``head.next.next.next.next = ``new` `Node(``4``);``    ``head.next.next.next.next.``                        ``next = ``new` `Node(``2``);``    ``head.next.next.next.next.``                ``next.next = ``new` `Node(``1``);` `    ``System.out.println( ``"Linked list before replacing"``        ``+ ``" duplicates\n"``);``    ``printList(head);` `    ``replaceDuplicates(head);` `    ``System.out.println(``"Linked list after replacing"``        ``+ ``" duplicates\n"``);``    ``printList(head);``}``}` `// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 implementation of the approach`` ` `# A linked list node``class` `Node:``    ` `    ``def` `__init__(``self``, data):``        ` `        ``self``.data ``=` `data``        ``self``.``next` `=` `None` `# Utility function to create a new Node``def` `newNode(data):` `    ``temp ``=` `Node(data)``    ``return` `temp``    ` `# Function to replace duplicates from a``# linked list``def` `replaceDuplicates(head):``    ` `    ``# Map to store the frequency of numbers``    ``mymap ``=` `dict``()`` ` `    ``temp ``=` `head`` ` `    ``# Variable to store the maximum number``    ``# in linked list``    ``maxNum ``=` `0``    ` `    ``# Traverse the linked list to store``    ``# the frequency of every number and``    ``# find the maximum integer``    ``while` `(temp):``        ``if` `temp.data ``not` `in` `mymap:``            ``mymap[temp.data] ``=` `0``            ` `        ``mymap[temp.data] ``+``=` `1``        ` `        ``if` `(maxNum < temp.data):``            ``maxNum ``=` `temp.data``            ` `        ``temp ``=` `temp.``next` `    ``# Traverse again the linked list``    ``while` `(head):``     ` `        ``# Mark the node with frequency more``        ``# than 1 so that we can change the``        ``# 2nd occurrence of that number``        ``if` `(mymap[head.data] > ``1``):``            ``mymap[head.data] ``=` `-``1`` ` `        ``# -1 means number has occurred``        ``# before change its value``        ``elif` `(mymap[head.data] ``=``=` `-``1``):``            ``maxNum ``+``=` `1``            ``head.data ``=` `maxNum``            ` `        ``head ``=` `head.``next``    ` `# Function to print nodes in a given``# linked list``def` `printList(node):` `    ``while` `(node !``=` `None``):``        ``print``(node.data, end ``=` `' '``)``        ``node ``=` `node.``next``        ` `    ``print``()`` ` `# Driver code``if` `__name__``=``=``'__main__'``:``    ` `    ``# The constructed linked list is:``    ``# 1.3.1.4.4.2.1``    ``head ``=` `newNode(``1``)``    ``head.``next` `=` `newNode(``3``)``    ``head.``next``.``next` `=` `newNode(``1``)``    ``head.``next``.``next``.``next` `=` `newNode(``4``)``    ``head.``next``.``next``.``next``.``next` `=` `newNode(``4``)``    ``head.``next``.``next``.``next``.``next``.``next` `=` `newNode(``2``)``    ``head.``next``.``next``.``next``.``next``.``next``.``next` `=` `newNode(``1``)`` ` `    ``print``(``"Linked list before replacing duplicates"``)``    ``printList(head)`` ` `    ``replaceDuplicates(head)`` ` `    ``print``(``"Linked list after replacing duplicates"``)``    ``printList(head)` `# This code is contributed by rutvik_56`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``    ` `// Representation of node``class` `Node``{``    ``public` `int` `data;``    ``public` `Node next;``    ``public` `Node(``int` `d)``    ``{``        ``data = d;``        ``next = ``null``;``    ``}``};`  `// Function to insert a node at the beginning``static` `Node insert(Node head, ``int` `item)``{``    ``Node temp = ``new` `Node(0);``    ``temp.data = item;``    ``temp.next = head;``    ``head = temp;``    ``return` `head;``}` `// Function to replace duplicates from a``// linked list``static` `void` `replaceDuplicates( Node head)``{``    ``// map to store the frequency of numbers``    ``Dictionary<``int``,``               ``int``> mymap = ``new` `Dictionary<``int``,``                                           ``int``>();` `    ``Node temp = head;` `    ``// variable to store the maximum number``    ``// in linked list``    ``int` `maxNum = 0;` `    ``// traverse the linked list to store``    ``// the frequency of every number and``    ``// find the maximum integer``    ``while` `(temp != ``null``)``    ``{``        ``if``(mymap.ContainsKey(temp.data))``            ``mymap[temp.data] = mymap[temp.data] + 1;``        ``else``            ``mymap.Add(temp.data, 1);` `        ``if` `(maxNum < temp.data)``            ``maxNum = temp.data;``        ``temp = temp.next;``    ``}` `    ``// Traverse again the linked list``    ``while` `(head != ``null``)``    ``{``    ` `        ``// Mark the node with frequency more``        ``// than 1 so that we can change the``        ``// 2nd occurrence of that number``        ``if` `(mymap[head.data] > 1)``            ``mymap[head.data] = -1;` `        ``// -1 means number has occurred``        ``// before change its value``        ``else` `if` `(mymap[head.data] == -1)``            ``head.data = ++maxNum;` `        ``head = head.next;``    ``}``}` `// Function to print nodes in a given``// linked list``static` `void` `printList( Node node)``{``    ``while` `(node != ``null``)``    ``{``        ``Console.Write(``"{0} "``, node.data);``        ``node = node.next;``    ``}``}` `// Driver code``public` `static` `void` `Main(String []args)``{``    ` `    ``// The constructed linked list is:``    ``// 1->3->1->4->4->2->1/``    ``Node head = ``new` `Node(1);``    ``head.next = ``new` `Node(3);``    ``head.next.next = ``new` `Node(1);``    ``head.next.next.next = ``new` `Node(4);``    ``head.next.next.next.next = ``new` `Node(4);``    ``head.next.next.next.next.next = ``new` `Node(2);``    ``head.next.next.next.next.next.next = ``new` `Node(1);` `    ``Console.WriteLine(``"Linked list before"` `+``                      ``" replacing duplicates"``);``    ``printList(head);` `    ``replaceDuplicates(head);` `    ``Console.WriteLine(``"\nLinked list after"` `+``                      ``" replacing duplicates"``);``    ``printList(head);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

```Linked list before replacing duplicates
1 3 1 4 4 2 1