Remove all occurrences of duplicates from a sorted Linked List

10 Jun, 2022
Given a sorted linked list, delete all nodes that have duplicate numbers (all occurrences), leaving only numbers that appear once in the original list. Examples:
Input : 23->28->28->35->49->49->53->53
Output : 23->35

Input : 11->11->11->11->75->75
Output : empty List
Note that this is different from Remove Duplicates From Linked List
The idea is to maintain a pointer (prev) to the node which just previous to the block of nodes we are checking for duplicates. In the first example, the pointer prev would point to 23 while we check for duplicates for node 28. Once we reach the last duplicate node with value 28 (name it current pointer), we can make the next field of prev node to be the next of current and update current=current.next. This would delete the block of nodes with value 28 which has duplicates.
C++
C
Java
Python3
C#
Javascript
// C++ program to remove all// occurrences of duplicates// from a sorted linked list.#include <bits/stdc++.h>using namespace std; // A linked list nodestruct Node {    int data;    struct Node* next;}; // Utility function// to create a new Nodestruct Node* newNode(int data){    Node* temp = new Node;    temp->data = data;    temp->next = NULL;    return temp;} // Function to print nodes// in a given linked list.void printList(struct Node* node){    while (node != NULL) {        cout<<node->data<<" ";        node = node->next;    }} // Function to remove all occurrences// of duplicate elementsvoid removeAllDuplicates(struct Node*& start){    // create a dummy node    // that acts like a fake    // head of list pointing    // to the original head    Node* dummy = new Node;     // dummy node points    // to the original head    dummy->next = start;     // Node pointing to last    // node which has no duplicate.    Node* prev = dummy;     // Node used to traverse    // the linked list.    Node* current = start;     while (current != NULL) {        // Until the current and        // previous values are        // same, keep updating current        while (current->next != NULL && prev->next->data == current->next->data)            current = current->next;         // if current has unique value        // i.e current is not updated,        // Move the prev pointer to        // next node        if (prev->next == current)            prev = prev->next;         // when current is updated        // to the last duplicate        // value of that segment,        // make prev the next of current        else            prev->next = current->next;         current = current->next;    }     // update original head to    // the next of dummy node    start = dummy->next;} // Driver Codeint main(){    // 23->28->28->35->49->49->53->53    struct Node* start = newNode(23);    start->next = newNode(28);    start->next->next = newNode(28);    start->next->next->next = newNode(35);    start->next->next->next->next = newNode(49);    start->next->next->next->next->next = newNode(49);    start->next->next->next->next->next->next = newNode(53);    start->next->next->next->next->next->next->next = newNode(53);    cout << "List before removal of duplicates\n";    printList(start);     removeAllDuplicates(start);     cout << "\nList after removal of duplicates\n";    printList(start);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// C++ program to remove all// occurrences of duplicates// from a sorted linked list.#include<stdio.h>#include<stdlib.h> // A linked list nodetypedef struct Node {    int data;    struct Node* next;}Node; // Utility function// to create a new Nodestruct Node* newNode(int data){    Node* temp = (Node *)malloc(sizeof(Node));    temp->data = data;    temp->next = NULL;    return temp;} // Function to print nodes// in a given linked list.void printList(Node* node){    while (node != NULL) {        printf("%d ", node->data);        node = node->next;    }} // Function to remove all occurrences// of duplicate elementsvoid removeAllDuplicates(Node* start){    // create a dummy node    // that acts like a fake    // head of list pointing    // to the original head    Node* dummy = (Node *)malloc(sizeof(Node));     // dummy node points    // to the original head    dummy->next = start;     // Node pointing to last    // node which has no duplicate.    Node* prev = dummy;     // Node used to traverse    // the linked list.    Node* current = start;     while (current != NULL) {        // Until the current and        // previous values are        // same, keep updating current        while (current->next != NULL && prev->next->data == current->next->data)            current = current->next;         // if current has unique value        // i.e current is not updated,        // Move the prev pointer to        // next node        if (prev->next == current)            prev = prev->next;         // when current is updated        // to the last duplicate        // value of that segment,        // make prev the next of current        else            prev->next = current->next;         current = current->next;    }     // update original head to    // the next of dummy node    start = dummy->next;} // Driver Codeint main(){    // 23->28->28->35->49->49->53->53    struct Node* start = newNode(23);    start->next = newNode(28);    start->next->next = newNode(28);    start->next->next->next = newNode(35);    start->next->next->next->next = newNode(49);    start->next->next->next->next->next = newNode(49);    start->next->next->next->next->next->next = newNode(53);    start->next->next->next->next->next->next->next = newNode(53);    printf("List before removal of duplicates\n");    printList(start);     removeAllDuplicates(start);     printf("\nList after removal of duplicates\n");    printList(start);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// Java program to remove all occurrences of// duplicates from a sorted linked list // class to create Linked lIstclass LinkedList{     // head of linked listNode head = null;class Node{         // value in the node    int val;    Node next;    Node(int v)    {                 // default value of the next        // pointer field        val = v;        next = null;    }} // Function to insert data nodes into// the Linked List at the frontpublic void insert(int data){    Node new_node = new Node(data);    new_node.next = head;    head = new_node;} // Function to remove all occurrences// of duplicate elementspublic void removeAllDuplicates(){         // Create a dummy node that acts like a fake    // head of list pointing to the original head    Node dummy = new Node(0);     // Dummy node points to the original head    dummy.next = head;    Node prev = dummy;    Node current = head;     while (current != null)    {        // Until the current and previous values        // are same, keep updating current        while (current.next != null &&               prev.next.val == current.next.val)               current = current.next;         // If current has unique value i.e current        // is not updated, Move the prev pointer        // to next node        if (prev.next == current)            prev = prev.next;         // When current is updated to the last        // duplicate value of that segment, make        // prev the next of current*/        else            prev.next = current.next;         current = current.next;    }     // Update original head to the next of dummy    // node    head = dummy.next;} // Function to print the list elementspublic void printList(){    Node trav = head;    if (head == null)        System.out.print(" List is empty" );             while (trav != null)    {        System.out.print(trav.val + " ");        trav = trav.next;    }} // Driver codepublic static void main(String[] args){    LinkedList ll = new LinkedList();    ll.insert(53);    ll.insert(53);    ll.insert(49);    ll.insert(49);    ll.insert(35);    ll.insert(28);    ll.insert(28);    ll.insert(23);         System.out.println("Before removal of duplicates");    ll.printList();     ll.removeAllDuplicates();     System.out.println("\nAfter removal of duplicates");    ll.printList();}}
# Python3 implementation for the above approach # Creating nodeclass Node:    def __init__(self, val):        self.val = val        self.next = Noneclass LinkedList:    def __init__(self):        self.head = None             # add node into beganing of linked list    def push(self, new_data):        new_node = Node(new_data)        new_node.next = self.head        self.head = new_node        return new_node             # Function to remove all occurrences    # of duplicate elements    def removeAllDuplicates(self, temp):                 # temp is head node of linkedlist        curr = temp        # print(' print something')        head = prev = Node(None)        head.next = curr         # Here we use same as we do in removing        # duplicates and only extra thing is that        # we need to remove all elements        # having duplicates that we did in 30-31        while curr and curr.next:                         # until the current value and next            # value are same keep updating the current value            if curr.val == curr.next.val:                while(curr and curr.next and                      curr.val == curr.next.val):                    curr = curr.next                                         # still one of duplicate values left                    # so point prec to curr                curr = curr.next                prev.next = curr            else:                prev = prev.next                curr = curr.next        return head.next             # for print the linkedlist    def printList(self):        temp1 = self.head        while temp1 is not None:            print(temp1.val, end = " ")            temp1 = temp1.next                 # For getting head of linkedlist    def get_head(self):        return self.head # Driver Codeif __name__=='__main__':    llist = LinkedList()    llist.push(53)    llist.push(53)    llist.push(49)    llist.push(49)    llist.push(35)    llist.push(28)    llist.push(28)    llist.push(23)         print('Created linked list is:')    llist.printList()    print('\nLinked list after deletion of duplicates:')    head1 = llist.get_head()    #print(head1)    llist.removeAllDuplicates(head1)    llist.printList()         # This code is contributed# by PRAVEEN KUMAR(IIIT KALYANI)
/* C# program to remove all occurrences ofduplicates from a sorted linked list */ using System; /* class to create Linked lIst */public class LinkedList{    Node head = null; /* head of linked list */    class Node    {        public int val; /* value in the node */        public Node next;        public Node(int v)        {            /* default value of the next            pointer field */            val = v;            next = null;        }    }     /* Function to insert data nodes into    the Linked List at the front */    public void insert(int data)    {        Node new_node = new Node(data);        new_node.next = head;        head = new_node;    }     /* Function to remove all occurrences    of duplicate elements */    public void removeAllDuplicates()    {    /* create a dummy node that acts like a fake        head of list pointing to the original head*/        Node dummy = new Node(0);         /* dummy node points to the original head*/        dummy.next = head;        Node prev = dummy;        Node current = head;         while (current != null)        {            /* Until the current and previous values            are same, keep updating current */            while (current.next != null &&                prev.next.val == current.next.val)                current = current.next;             /* if current has unique value i.e current                is not updated, Move the prev pointer                to next node*/            if (prev.next == current)                prev = prev.next;             /* when current is updated to the last            duplicate value of that segment, make            prev the next of current*/            else                prev.next = current.next;             current = current.next;        }         /* update original head to the next of dummy        node */        head = dummy.next;    }     /* Function to print the list elements */    public void printList()    {        Node trav = head;        if (head == null)            Console.Write(" List is empty" );        while (trav != null)        {            Console.Write(trav.val + " ");            trav = trav.next;        }    }     /* Driver code */    public static void Main(String[] args)    {        LinkedList ll = new LinkedList();        ll.insert(53);        ll.insert(53);        ll.insert(49);        ll.insert(49);        ll.insert(35);        ll.insert(28);        ll.insert(28);        ll.insert(23);        Console.WriteLine("Before removal of duplicates");        ll.printList();         ll.removeAllDuplicates();         Console.WriteLine("\nAfter removal of duplicates");        ll.printList();    }} // This code is contributed by Rajput-Ji
// Remove all occurrences of duplicates from a sorted Linked List class Node {    constructor(val, next = null) {        this.data = val;        this.next = next;    }} const node1 = new Node(11);const node2 = new Node(11);const node3 = new Node(11);const node4 = new Node(75);const node5 = new Node(75);node1.next = node2;node2.next = node3;node3.next = node4;node4.next = node5; const removeDuplicate = (head) => {    let current = head;    let prev = null;    while(current) {        if (current.next && current.data == current.next.data) {           let pivot = current;           let newCurrent = current.next           while (newCurrent && pivot.data === newCurrent.data) {               // removing current;               pivot.next = newCurrent.next;               // increment               newCurrent = newCurrent.next;           }           // removing first duplicate element           if (prev) prev.next = pivot.next;           else head = pivot.next                       current = pivot.next        } else {            prev = current;            current = current.next;        }    }    return head;} console.log(JSON.stringify(removeDuplicate(node1)));
Output:
List before removal of duplicates
23 28 28 35 49 49 53 53 
List after removal of duplicates
23 35 
Time Complexity: O(n)
Auxiliary Space: O(1) because extra space is not required in removal of duplicatesThis article is contributed by Saloni Baweja. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
nik1996
Rajput-Ji
praveenkumar66
utkarshkalia
umadevi9616
shashankgpt270
adityakumar129
technophpfij
Linked List
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Stack Data Structure (Introduction and Program)
LinkedList in Java
Introduction to Data Structures
What is Data Structure: Types, Classifications and Applications
Implementing a Linked List in Java using Class
Add two numbers represented by linked lists | Set 1
Detect and Remove Loop in a Linked List
Queue - Linked List Implementation
Function to check if a singly linked list is palindrome
Implement a stack using singly linked list