Given an unsorted Linked List, the task is to remove duplicates from the list.
Examples:
Input: linked_list = 12 -> 11 -> 12 -> 21 -> 41 -> 43 -> 21
Output: 12 -> 11 -> 21 -> 41 -> 43
Explanation: Second occurrence of 12 and 21 are removed.Input: linked_list = 12 -> 11 -> 12 -> 21 -> 41 -> 43 -> 21
Output: 12 -> 11 -> 21 -> 41 -> 43
Naive Approach to Remove Duplicates from an Unsorted Linked List:
The most simple approach to solve this, is to check each node for duplicate in the Linked List one by one.
Below is the Implementation of the above approach:
// Java program to remove duplicates from unsorted // linked list class LinkedList {
static Node head;
static class Node {
int data;
Node next;
Node( int d)
{
data = d;
next = null ;
}
}
/* Function to remove duplicates from an
unsorted linked list */
void remove_duplicates()
{
Node ptr1 = null , ptr2 = null , dup = null ;
ptr1 = head;
/* Pick elements one by one */
while (ptr1 != null && ptr1.next != null ) {
ptr2 = ptr1;
/* Compare the picked element with rest
of the elements */
while (ptr2.next != null ) {
/* If duplicate then delete it */
if (ptr1.data == ptr2.next.data) {
/* sequence of steps is important here
*/
ptr2.next = ptr2.next.next;
System.gc();
}
else /* This is tricky */ {
ptr2 = ptr2.next;
}
}
ptr1 = ptr1.next;
}
}
void printList(Node node)
{
while (node != null ) {
System.out.print(node.data + " " );
node = node.next;
}
}
public static void main(String[] args)
{
LinkedList list = new LinkedList();
list.head = new Node( 10 );
list.head.next = new Node( 12 );
list.head.next.next = new Node( 11 );
list.head.next.next.next = new Node( 11 );
list.head.next.next.next.next = new Node( 12 );
list.head.next.next.next.next.next = new Node( 11 );
list.head.next.next.next.next.next.next
= new Node( 10 );
System.out.println(
"Linked List before removing duplicates : " );
list.printList(head);
list.remove_duplicates();
System.out.println( "\n" );
System.out.println(
"Linked List after removing duplicates : " );
list.printList(head);
}
} // This code has been contributed by Mayank Jaiswal |
Linked List before removing duplicates : 10 12 11 11 12 11 10 Linked List after removing duplicates : 10 12 11
Time Complexity: O(N2)
Auxiliary Space: O(1)
Remove duplicates from an Unsorted Linked List using Sorting:
Follow the below steps to Implement the idea:
- Sort the elements using Merge Sort for Linked Lists.
- Remove duplicates in linear time using the algorithm for removing duplicates in sorted Linked List.
Below is the implementation for above approach:
import java.io.*;
// structure of a node in the linked list class Node {
int data;
Node next;
Node( int d)
{
data = d;
next = null ;
}
} // class for the linked list class LinkedList {
Node head;
// function to insert a node in the linked list
public void push( int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
// function to sort the linked list
public void sortList()
{
// pointer to traverse the linked list
Node current = head;
Node index = null ;
// loop to traverse the linked list
while (current != null ) {
// loop to compare current node with all other
// nodes
index = current.next;
while (index != null ) {
// checking for duplicate values
if (current.data == index.data) {
// deleting the duplicate node
current.next = index.next;
index = current.next;
}
else {
index = index.next;
}
}
current = current.next;
}
}
// function to display the linked list
public void printList()
{
Node node = head;
while (node != null ) {
System.out.print(node.data + " " );
node = node.next;
}
System.out.println();
}
} // main class class Main {
public static void main(String[] args)
{
LinkedList ll = new LinkedList();
ll.push( 20 );
ll.push( 13 );
ll.push( 13 );
ll.push( 11 );
ll.push( 11 );
ll.push( 11 );
System.out.println(
"Linked List before removing duplicates : " );
ll.printList();
ll.sortList();
System.out.println(
"Linked List after removing duplicates : " );
ll.printList();
}
} |
Linked List before removing duplicates : 11 11 11 13 13 20 Linked List after removing duplicates : 11 13 20
Time Complexity: O(N log N)
Auxiliary Space: O(1)
Remove duplicates from an Unsorted Linked List using Hashing:
The idea for this approach is based on the following observations:
- Traverse the link list from head to end.
- For every newly encountered element, check whether if it is in the hash table:
- if yes, remove it
- otherwise put it in the hash table.
- At the end, the Hash table will contain only the unique elements.
Below is the implementation of the above approach:
// Java program to remove duplicates // from unsorted linkedlist import java.util.HashSet;
public class removeDuplicates {
static class node {
int val;
node next;
public node( int val) { this .val = val; }
}
/* Function to remove duplicates from a
unsorted linked list */
static void removeDuplicate(node head)
{
// Hash to store seen values
HashSet<Integer> hs = new HashSet<>();
/* Pick elements one by one */
node current = head;
node prev = null ;
while (current != null ) {
int curval = current.val;
// If current value is seen before
if (hs.contains(curval)) {
prev.next = current.next;
}
else {
hs.add(curval);
prev = current;
}
current = current.next;
}
}
/* Function to print nodes in a given linked list */
static void printList(node head)
{
while (head != null ) {
System.out.print(head.val + " " );
head = head.next;
}
}
public static void main(String[] args)
{
/* The constructed linked list is:
10->12->11->11->12->11->10*/
node start = new node( 10 );
start.next = new node( 12 );
start.next.next = new node( 11 );
start.next.next.next = new node( 11 );
start.next.next.next.next = new node( 12 );
start.next.next.next.next.next = new node( 11 );
start.next.next.next.next.next.next = new node( 10 );
System.out.println(
"Linked list before removing duplicates :" );
printList(start);
removeDuplicate(start);
System.out.println(
"\nLinked list after removing duplicates :" );
printList(start);
}
} // This code is contributed by Rishabh Mahrsee |
Linked list before removing duplicates : 10 12 11 11 12 11 10 Linked list after removing duplicates : 10 12 11
Time Complexity: O(N), on average (assuming that hash table access time is O(1) on average).
Auxiliary Space: O(N), As extra space is used to store the elements in the stack.