# Modify a Linked List to contain last occurrences of every duplicate element

• Last Updated : 07 Feb, 2022

Given an unsorted Singly Linked List consisting of N nodes that may contain duplicate elements, the task is to remove all but the last occurrence of duplicate elements from the Linked List.

Examples:

Input: 1 -> 2 -> 7 -> 3 -> 2 -> 5 -> 1
Output: 7 -> 3 -> 2 -> 5 -> 1
Explanation:
Given Linked List: 1 -> 2 -> 7 -> 3 -> 2 -> 5 -> 1
Duplicate elements: 1, 2
Modified Linked List: 7 -> 3 -> 2 -> 5 -> 1

Input: 1 -> 2 -> 3 -> 4 -> 5
Output: 1 -> 2 -> 3 -> 4 -> 5

Approach: Follow the steps below to solve the problem:

• Initialize a dummy node and make it’s next point to head.
• Reverse the given Linked List.
• Initialize an unordered set, say visited, to store the already visited nodes.
• Initialize two nodes, say currnode, pointing to the dummy node, and nextnode, to store the next node of the current node.
• Iterate over the linked list and check if data of the next node of the current node is already visited or not.
• If it is already visited, then perform the following steps:
• Initialize a new node, say duplicate, to store the nextnode which is a duplicate node in this case.
• Make current’s next point to next of the nextnode.
• Otherwise:
• Insert the data of nextnode into the visited set.
• Make nextnode as currentnode.
• Finally, reverse the modified linked list and return.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Node class` `class` `Node {` `public``:` `    ``int` `data;` `    ``Node* next;`   `    ``Node(``int` `x)` `    ``{` `        ``this``->data = x;` `        ``this``->next = NULL;` `    ``}` `};`   `// Function to reverse a Linked List` `Node* reverseList(Node* head)` `{` `    ``Node *prev = NULL, *nextNode = NULL;` `    ``while` `(head != NULL) {`   `        ``// Point to next node` `        ``// of the current node` `        ``nextNode = head->next;`   `        ``// Point next of current` `        ``// to the previous node` `        ``head->next = prev;`   `        ``prev = head;`   `        ``head = nextNode;` `    ``}` `    ``return` `prev;` `}`   `// Function to modify a linked list` `// such that it contains only the` `// last occurrence of duplicate elements` `Node* Remove_Dup_Keep_Last_Occurence(` `    ``Node* head)` `{` `    ``// Make a dummy node` `    ``Node* dummy = ``new` `Node(-1);` `    ``dummy->next = head;`   `    ``// Reverse the given Linked List` `    ``dummy->next = reverseList(dummy->next);`   `    ``// Stores duplicate elements` `    ``unordered_set<``int``> visited;`   `    ``Node *currNode = dummy, *nextNode;`   `    ``// Iterate over the list` `    ``while` `(currNode != NULL` `           ``&& currNode->next != NULL) {`   `        ``nextNode = currNode->next;`   `        ``// Check if data of the next node of the` `        ``// current node is already visited or not` `        ``if` `(visited.count(nextNode->data) != 0) {`   `            ``// Stores the duplicate pointer` `            ``Node* duplicate = nextNode;` `            ``currNode->next = nextNode->next;`   `            ``// Erase memory of duplicate pointer` `            ``delete` `duplicate;` `        ``}` `        ``else` `{`   `            ``// Mark as visited to data of nextNode` `            ``visited.insert(nextNode->data);`   `            ``// Go for the next node` `            ``currNode = nextNode;` `        ``}` `    ``}`   `    ``// Reverse the modified linked list` `    ``dummy->next = reverseList(dummy->next);`   `    ``return` `dummy->next;` `}`   `// Function to print a Linked List` `void` `print_Linked_List(Node* head)` `{` `    ``Node* curr = head;` `    ``while` `(curr != NULL) {` `        ``cout << curr->data << ``' '``;` `        ``curr = curr->next;` `    ``}` `}`   `// Driver Code` `int` `main()` `{`   `    ``// Given Input` `    ``Node* head = ``new` `Node(3);` `    ``head->next = ``new` `Node(2);` `    ``head->next->next = ``new` `Node(3);` `    ``head->next->next->next = ``new` `Node(1);` `    ``head->next->next->next->next = ``new` `Node(5);` `    ``head->next->next->next->next->next = ``new` `Node(1);` `    ``head->next->next->next->next->next->next = ``new` `Node(6);`   `    ``head = Remove_Dup_Keep_Last_Occurence(head);`   `    ``// Function Call` `    ``print_Linked_List(head);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG` `{`   `// Node class` `static` `class` `Node {` `    ``int` `data;` `    ``Node next;`   `    ``Node(``int` `x)` `    ``{` `        ``this``.data = x;` `        ``this``.next = ``null``;` `    ``}` `};`   `// Function to reverse a Linked List` `static` `Node reverseList(Node head)` `{` `    ``Node prev = ``null``, nextNode = ``null``;` `    ``while` `(head != ``null``) {`   `        ``// Point to next node` `        ``// of the current node` `        ``nextNode = head.next;`   `        ``// Point next of current` `        ``// to the previous node` `        ``head.next = prev;`   `        ``prev = head;`   `        ``head = nextNode;` `    ``}` `    ``return` `prev;` `}`   `// Function to modify a linked list` `// such that it contains only the` `// last occurrence of duplicate elements` `static` `Node Remove_Dup_Keep_Last_Occurence(` `    ``Node head)` `{` `    ``// Make a dummy node` `    ``Node dummy = ``new` `Node(-``1``);` `    ``dummy.next = head;`   `    ``// Reverse the given Linked List` `    ``dummy.next = reverseList(dummy.next);`   `    ``// Stores duplicate elements` `    ``HashSet visited = ``new` `HashSet();`   `    ``Node currNode = dummy;` `    ``Node nextNode;`   `    ``// Iterate over the list` `    ``while` `(currNode != ``null` `           ``&& currNode.next != ``null``) {`   `        ``nextNode = currNode.next;`   `        ``// Check if data of the next node of the` `        ``// current node is already visited or not` `        ``if` `(visited.contains(nextNode.data)) {`   `            ``// Stores the duplicate pointer` `            ``Node duplicate = nextNode;` `            ``currNode.next = nextNode.next;`   `            ``// Erase memory of duplicate pointer` `            ``duplicate=``null``;` `        ``}` `        ``else` `{`   `            ``// Mark as visited to data of nextNode` `            ``visited.add(nextNode.data);`   `            ``// Go for the next node` `            ``currNode = nextNode;` `        ``}` `    ``}`   `    ``// Reverse the modified linked list` `    ``dummy.next = reverseList(dummy.next);`   `    ``return` `dummy.next;` `}`   `// Function to print a Linked List` `static` `void` `print_Linked_List(Node head)` `{` `    ``Node curr = head;` `    ``while` `(curr != ``null``) {` `        ``System.out.print(curr.data +``" "``);` `        ``curr = curr.next;` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{`   `    ``// Given Input` `    ``Node head = ``new` `Node(``3``);` `    ``head.next = ``new` `Node(``2``);` `    ``head.next.next = ``new` `Node(``3``);` `    ``head.next.next.next = ``new` `Node(``1``);` `    ``head.next.next.next.next = ``new` `Node(``5``);` `    ``head.next.next.next.next.next = ``new` `Node(``1``);` `    ``head.next.next.next.next.next.next = ``new` `Node(``6``);`   `    ``head = Remove_Dup_Keep_Last_Occurence(head);`   `    ``// Function Call` `    ``print_Linked_List(head);`   `}` `}`   `// This code is contributed by shikhasingrajput`

## Python3

 `# Python program for the above approach`   `# Node class` `class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data;` `        ``self``.``next` `=` `None``;`   `# Function to reverse a Linked List` `def` `reverseList(head):` `    ``prev ``=` `None``;` `    ``nextNode ``=` `None``;` `    ``while` `(head !``=` `None``):` `        ``# Point to next Node` `        ``# of the current Node` `        ``nextNode ``=` `head.``next``;`   `        ``# Point next of current` `        ``# to the previous Node` `        ``head.``next` `=` `prev;`   `        ``prev ``=` `head;`   `        ``head ``=` `nextNode;`   `    ``return` `prev;`   `# Function to modify a linked list` `# such that it contains only the` `# last occurrence of duplicate elements` `def` `Remove_Dup_Keep_Last_Occurence(head):` `    ``# Make a dummy Node` `    ``dummy ``=` `Node(``-``1``);` `    ``dummy.``next` `=` `head;`   `    ``# Reverse the given Linked List` `    ``dummy.``next` `=` `reverseList(dummy.``next``);`   `    ``# Stores duplicate elements` `    ``visited ``=``set``();` `    ``currNode ``=` `dummy;` `    ``nextNode ``=` `None``;`   `    ``# Iterate over the list` `    ``while` `(currNode !``=` `None` `and` `currNode.``next` `!``=` `None``):`   `        ``nextNode ``=` `currNode.``next``;`   `        ``# Check if data of the next Node of the` `        ``# current Node is already visited or not` `        ``if` `(visited.__contains__(nextNode.data)):`   `            ``# Stores the duplicate pointer` `            ``duplicate ``=` `nextNode;` `            ``currNode.``next` `=` `nextNode.``next``;`   `            ``# Erase memory of duplicate pointer` `            ``duplicate ``=` `None``;` `        ``else``:`   `            ``# Mark as visited to data of nextNode` `            ``visited.add(nextNode.data);`   `            ``# Go for the next Node` `            ``currNode ``=` `nextNode;`   `    ``# Reverse the modified linked list` `    ``dummy.``next` `=` `reverseList(dummy.``next``);`   `    ``return` `dummy.``next``;`     `# Function to pra Linked List` `def` `print_Linked_List(head):` `    ``curr ``=` `head;` `    ``while` `(curr !``=` `None``):` `        ``print``(curr.data, end``=``" "``);` `        ``curr ``=` `curr.``next``;`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``# Given Input` `    ``head ``=` `Node(``3``);` `    ``head.``next` `=` `Node(``2``);` `    ``head.``next``.``next` `=` `Node(``3``);` `    ``head.``next``.``next``.``next` `=` `Node(``1``);` `    ``head.``next``.``next``.``next``.``next` `=` `Node(``5``);` `    ``head.``next``.``next``.``next``.``next``.``next` `=` `Node(``1``);` `    ``head.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``6``);`   `    ``head ``=` `Remove_Dup_Keep_Last_Occurence(head);`   `    ``# Function Call` `    ``print_Linked_List(head);`   `# This code is contributed by shikhasingrajput`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `    ``// Node class` `public`    `class` `Node {` `    ``public`    `int` `data;` `    ``public`    `Node next;`   `    ``public`    `Node(``int` `x) {` `            ``this``.data = x;` `            ``this``.next = ``null``;` `        ``}` `    ``};`   `    ``// Function to reverse a Linked List` `    ``static` `Node reverseList(Node head) {` `        ``Node prev = ``null``, nextNode = ``null``;` `        ``while` `(head != ``null``) {`   `            ``// Point to next node` `            ``// of the current node` `            ``nextNode = head.next;`   `            ``// Point next of current` `            ``// to the previous node` `            ``head.next = prev;`   `            ``prev = head;`   `            ``head = nextNode;` `        ``}` `        ``return` `prev;` `    ``}`   `    ``// Function to modify a linked list` `    ``// such that it contains only the` `    ``// last occurrence of duplicate elements` `    ``static` `Node Remove_Dup_Keep_Last_Occurence(Node head)` `    ``{` `      `  `        ``// Make a dummy node` `        ``Node dummy = ``new` `Node(-1);` `        ``dummy.next = head;`   `        ``// Reverse the given Linked List` `        ``dummy.next = reverseList(dummy.next);`   `        ``// Stores duplicate elements` `        ``HashSet<``int``> visited = ``new` `HashSet<``int``>();`   `        ``Node currNode = dummy;` `        ``Node nextNode;`   `        ``// Iterate over the list` `        ``while` `(currNode != ``null` `&& currNode.next != ``null``) {`   `            ``nextNode = currNode.next;`   `            ``// Check if data of the next node of the` `            ``// current node is already visited or not` `            ``if` `(visited.Contains(nextNode.data)) {`   `                ``// Stores the duplicate pointer` `                ``Node duplicate = nextNode;` `                ``currNode.next = nextNode.next;`   `                ``// Erase memory of duplicate pointer` `                ``duplicate = ``null``;` `            ``} ``else` `{`   `                ``// Mark as visited to data of nextNode` `                ``visited.Add(nextNode.data);`   `                ``// Go for the next node` `                ``currNode = nextNode;` `            ``}` `        ``}`   `        ``// Reverse the modified linked list` `        ``dummy.next = reverseList(dummy.next);`   `        ``return` `dummy.next;` `    ``}`   `    ``// Function to print a Linked List` `    ``static` `void` `print_Linked_List(Node head) {` `        ``Node curr = head;` `        ``while` `(curr != ``null``) {` `            ``Console.Write(curr.data + ``" "``);` `            ``curr = curr.next;` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args) {`   `        ``// Given Input` `        ``Node head = ``new` `Node(3);` `        ``head.next = ``new` `Node(2);` `        ``head.next.next = ``new` `Node(3);` `        ``head.next.next.next = ``new` `Node(1);` `        ``head.next.next.next.next = ``new` `Node(5);` `        ``head.next.next.next.next.next = ``new` `Node(1);` `        ``head.next.next.next.next.next.next = ``new` `Node(6);`   `        ``head = Remove_Dup_Keep_Last_Occurence(head);`   `        ``// Function Call` `        ``print_Linked_List(head);`   `    ``}` `}`   `// This code is contributed by umadevi9616 `

## Javascript

 ``

Output:

`2 3 5 1 6`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :