Open In App

Replace nodes with duplicates in linked list

Improve
Improve
Like Article
Like
Save
Share
Report

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:  

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. he 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 <bits/stdc++.h>
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<Integer, Integer> 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




<script>
 
// JavaScript implementation of the approach
 
// Representation of node
class Node
{
    constructor(d)
    {
        this.data = d;
        this.next = null;
    }
}
 
// Function to insert a node at the beginning
function insert(head, item)
{
    var temp = new Node(0);
    temp.data = item;
    temp.next = head;
    head = temp;
    return head;
}
 
// Function to replace duplicates from a
// linked list
function replaceDuplicates(head)
{
     
    // Map to store the frequency of numbers
    var mymap = {};
     
    var temp = head;
     
    // Variable to store the maximum number
    // in linked list
    var maxNum = 0;
     
    // Traverse the linked list to store
    // the frequency of every number and
    // find the maximum integer
    while (temp != null)
    {
        if (mymap.hasOwnProperty(temp.data))
            mymap[temp.data] = mymap[temp.data] + 1;
        else mymap[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
function printList(node)
{
    while (node != null)
    {
        document.write(node.data + " ");
        node = node.next;
    }
}
 
// Driver code
 
// The constructed linked list is:
// 1->3->1->4->4->2->1/
var 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);
 
document.write("Linked list before " +
               "replacing duplicates <br>");
printList(head);
replaceDuplicates(head);
 
document.write("<br>Linked list after " +
               "replacing duplicates <br>");
printList(head);
 
// This code is contributed by rdtank
 
</script>


Output

Linked list before replacing duplicates
1 3 1 4 4 2 1 
Linked list after replacing duplicates
1 3 5 4 6 2 7 

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

 



Last Updated : 23 Jan, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads