Remove Duplicates in a Sorted Linked List-Interview Problem

Difficulty: Medium
Asked in: Myntra, Oracle, Visa, Adobe

Understanding the Problem

Problem Description: Given a sorted linked list which has some duplicate elements, your task is to remove all the duplicate elements from the given Linked List. As a result of solving this problem, your Linked List will only have all unique elements.

For example:

Input:  2->3->3->4->5->7->7->9->NULL
Output: 2->3->4->5->7->9->NULL
Explanation: All the duplicate elements have been removed.
Similarly,
Input: 4->7->9->9->10->11->11->NULL
Output: 4->7->9->10->11->NULL

Possible follow-up questions to ask the interviewer: →

  • Can we modify the given Linked List or have to create a new Linked List? (Ans: You have to modify the same Linked List)

Solutions

We are going to discuss two possible ways to solve this problem: →

  • Iterative Solution: Here we will use simple iteration to iterate through the nodes and delete(remove) duplicate nodes from the given Linked List.
  • Recursive Solution: In this solution, we will use recursion to achieve having only unique elements in our Linked List.

Approach 1: Iterative Solution

Solution idea

In this approach, we will iteratively traverse the entire Linked List. Going to each node one by one, we will compare that node with the adjacent node. If the data value for both the nodes are the same it means that the node is duplicate. We will then de-link one of the duplicate nodes and will follow the same procedure for the rest of the nodes.

Solution steps
  • We will store the value of the head(start) node into another variable say current.
  • We will keep iterating through the linked list until we reach the end node.
  • If there is a match of data values between a node and an adjacent node we will detach one of the nodes by saving its neighbour node’s address into the NextNode variable.
  • We will then delete that duplicate node and attach the previous node of the deleted duplicate node with NextNode.
  • We will keep doing the same for all duplicate nodes if encountered.
Pseudo-code
ListNode removeDuplicatedFromLL(ListNode head)
{
     ListNode current = head;
        
     while(current!=NULL && current.next!=NULL)
     {
         ListNode NextNode = NULL;
         if(current.data == current.next.data)
         {
             NextNode = current.next.next
             delete current.next;  
             current.next = NextNode;
         }
         else
             current = current.next
     }
}
Complexity Analysis

Time Complexity: O(N), where N is the size of the array.

Space Complexity: O(1)(Why?)

Critical ideas to think!
  • Do you think removing duplicates from Linked List is simpler than that from an array? Why or Why not?

Approach 2: Recursive Solution

Solution idea

Here also the basic approach is completely the same, the only difference is in the implementation. The above solution is implemented by using an iterative solution, in this, we will make a recursive solution. For a recursive solution, we need to think about the base condition, an easy operation for us to do and the sub-task that we will leave on recursion. The operation is to compare two nodes and to see if the data values are the same or not.

Solution steps
  • We will decide upon the base case, the base case will be when there is only one node or there is no node at all.
  • We will perform our small task of comparing the head node with its adjacent node.
  • We will perform the necessary things based on the condition. If the nodes match we will save the neighbor’s address and delete the duplicate node.
  • We will recursively call for the rest of the nodes and leave the sub-tasks on recursion.
Pseudo-code
void removeDuplicatesFromLL(ListNode head)
{
    if(head==NULL or head.next==NULL)
       return
    if(head.data == head.next.data)
    {
        ListNode NextNode = head.next.next
        delete head.next
        head.next = NextNode
        removeDuplicatesFromLL(head)
   }
    else
        removeDuplicatesFromLL(head.next)
}
Complexity Analysis

Time Complexity: O(N)

Space Complexity: O(N)

Comparison of Different Solutions

Suggested Problems to Solve

  • Find the most frequent character in a sentence
  • Remove elements to make array sorted
  • Remove duplicates from an unsorted array using Map
  • Remove duplicate elements from a linked list and also the size of the linked list after removing those duplicates

Happy Coding! Enjoy Algorithms!!