Delete duplicate-value nodes from a sorted linked list

                            Solution in C :

In C++ :


/*
  Remove all duplicate elements from a sorted linked list
  Node is defined as 
  struct Node
  {
     int data;
     struct Node *next;
  }
*/
Node* RemoveDuplicates(Node *head)
{
  // This is a "method-only" submission. 
  // You only need to complete this method. 
    
    Node *ptr = head,*temp=NULL,*tmp=NULL;
    
    while(ptr!=NULL && ptr->next!=NULL)
    {
        temp = ptr->next;
        ptr->next=NULL;
        
        while(temp!=NULL && ptr->data == temp->data)
        {
            tmp=temp;
            temp=temp->next;
            
            tmp->next=NULL;
            delete(tmp);
        }
        ptr->next = temp;
        ptr = temp;
    }
    
    return head;
}



In Java : 


Node RemoveDuplicates(Node head) {
  // This is a "method-only" submission. 
  // You only need to complete this method. 
    
    if(head==null)
        return null;
    
    Node temp=head.next;
    Node prev=head;
    while(temp!=null)
        {
        
         if(prev.data==temp.data)
             {
             prev.next=temp.next;
             temp.next=null;
             temp=prev.next;
         }
        else
            {
              prev=temp;
              temp=temp.next;
        
        }
    }
    return head;
}



In python3 :


"""
 Delete duplicate nodes
 head could be None as well for empty list
 Node is defined as
 
 class Node(object):
 
   def __init__(self, data=None, next_node=None):
       self.data = data
       self.next = next_node

 return back the head of the linked list in the below method.
"""

def RemoveDuplicates(head):
    c = head
    p = None
    if c==None or c.next==None:
        return(head)
    else:
        p=c
        c=c.next
    while c!= None:
        if p.data==c.data:
            p.next = c.next
            c=c.next
        else:
            p = p.next
            c = c.next
    return(head)
  
  
  
  
  
  
  
 In C :


// Complete the removeDuplicates function below.

/*
 * For your reference:
 *
 * SinglyLinkedListNode {
 *     int data;
 *     SinglyLinkedListNode* next;
 * };
 *
 */
SinglyLinkedListNode* removeDuplicates(SinglyLinkedListNode* head) {
    struct SinglyLinkedListNode*temp1=head;
    struct SinglyLinkedListNode*temp=head->next;
    while(temp!=NULL)
    {
        if(head->data==temp->data)
        {
            temp=temp->next;
            head->next=temp;
        }
        else
        {
         head=temp;
         temp=temp->next;
        }
    }
 return temp1;

}