Skip to content
Related Articles

Related Articles

Merge two sorted linked list without duplicates

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Easy
  • Last Updated : 29 Dec, 2020

Merge two sorted linked list of size n1 and n2. The duplicates in two linked list should be present only once in the final sorted linked list.

Examples:  

Input : list1: 1->1->4->5->7
        list2: 2->4->7->9
Output : 1 2 4 5 7 9

Source: Microsoft on Campus Placement and Interview Questions

Approach: Following are the steps: 

  1. Merge the two sorted linked list in sorted manner. Refer recursive approach of this post. Let the final obtained list be head.
  2. Remove duplicates from sorted linked list head.

C++




// C++ implementation to merge two sorted linked list
// without duplicates
#include <bits/stdc++.h>
 
using namespace std;
 
// structure of a node
struct Node {
    int data;
    Node* next;
};
 
// function to get a new node
Node* getNode(int data)
{
    // allocate space
    Node* temp = (Node*)malloc(sizeof(Node));
 
    // put in data
    temp->data = data;
    temp->next = NULL;
    return temp;
}
 
// function to merge two sorted linked list
// in a sorted manner
Node* sortedMerge(struct Node* a, struct Node* b)
{
    Node* result = NULL;
 
    /* Base cases */
    if (a == NULL)
        return (b);
    else if (b == NULL)
        return (a);
 
    /* Pick either a or b, and recur */
    if (a->data <= b->data) {
        result = a;
        result->next = sortedMerge(a->next, b);
    }
    else {
        result = b;
        result->next = sortedMerge(a, b->next);
    }
    return (result);
}
 
/* The function removes duplicates from a sorted list */
void removeDuplicates(Node* head)
{
    /* Pointer to traverse the linked list */
    Node* current = head;
 
    /* Pointer to store the next pointer of a node to be deleted*/
    Node* next_next;
 
    /* do nothing if the list is empty */
    if (current == NULL)
        return;
 
    /* Traverse the list till last node */
    while (current->next != NULL) {
 
        /* Compare current node with next node */
        if (current->data == current->next->data) {
 
            /* The sequence of steps is important*/
            next_next = current->next->next;
            free(current->next);
            current->next = next_next;
        }
        else /* This is tricky: only advance if no deletion */
        {
            current = current->next;
        }
    }
}
 
// function to merge two sorted linked list
// without duplicates
Node* sortedMergeWithoutDuplicates(Node* head1, Node* head2)
{
    // merge two linked list in sorted manner
    Node* head = sortedMerge(head1, head2);
 
    // remove duplicates from the list 'head'
    removeDuplicates(head);
 
    return head;
}
 
// function to print the linked list
void printList(Node* head)
{
    while (head != NULL) {
        cout << head->data << " ";
        head = head->next;
    }
}
 
// Driver program to test above
int main()
{
    // head1: 1->1->4->5->7
    Node* head1 = getNode(1);
    head1->next = getNode(1);
    head1->next->next = getNode(4);
    head1->next->next->next = getNode(5);
    head1->next->next->next->next = getNode(7);
 
    // head2: 2->4->7->9
    Node* head2 = getNode(2);
    head2->next = getNode(4);
    head2->next->next = getNode(7);
    head2->next->next->next = getNode(9);
 
    Node* head3;
 
    head3 = sortedMergeWithoutDuplicates(head1, head2);
 
    printList(head3);
 
    return 0;
}


Python3




# Python3 implementation to merge two
# sorted linked list without duplicates
  
# Structure of a node
class Node:
     
    def __init__(self, data):
         
        self.data = data
        self.next = None
  
# Function to get a new node
def getNode(data):
     
    # Allocate space
    temp = Node(data)
    return temp
 
# Function to merge two sorted linked
# list in a sorted manner
def sortedMerge(a, b):
     
    result = None
  
    # Base cases
    if (a == None):
        return(b)
    elif (b == None):
        return(a)
  
    # Pick either a or b, and recur
    if (a.data <= b.data):
        result = a
        result.next = sortedMerge(a.next, b)
    else:
        result = b
        result.next = sortedMerge(a, b.next)
 
    return(result)
     
# The function removes duplicates
# from a sorted list
def removeDuplicates(head):
 
    # Pointer to traverse the linked list
    current = head
  
    # Pointer to store the next pointer
    # of a node to be deleted
    next_next = None
  
    # Do nothing if the list is empty
    if (current == None):
        return
  
    # Traverse the list till last node
    while (current.next != None):
  
        # Compare current node with next node
        if (current.data == current.next.data):
  
            # The sequence of steps is important
            next_next = current.next.next
            del (current.next)
            current.next = next_next
        else:
             
            # This is tricky: only advance
            # if no deletion
            current = current.next
     
# Function to merge two sorted linked list
# without duplicates
def sortedMergeWithoutDuplicates(head1, head2):
 
    # Merge two linked list in sorted manner
    head = sortedMerge(head1, head2)
  
    # Remove duplicates from the list 'head'
    removeDuplicates(head)
  
    return head
 
# Function to print the linked list
def printList(head):
 
    while (head != None):
        print(head.data, end = ' ')   
        head = head.next
     
# Driver code
if __name__=='__main__':
     
    # head1: 1.1.4.5.7
    head1 = getNode(1)
    head1.next = getNode(1)
    head1.next.next = getNode(4)
    head1.next.next.next = getNode(5)
    head1.next.next.next.next = getNode(7)
  
    # head2: 2.4.7.9
    head2 = getNode(2)
    head2.next = getNode(4)
    head2.next.next = getNode(7)
    head2.next.next.next = getNode(9)
  
    head3 = sortedMergeWithoutDuplicates(
        head1, head2)
  
    printList(head3)
  
# This code is contributed by rutvik_56


Output: 

1 2 4 5 7 9

Time complexity: O(n1 + n2). 
Auxiliary Space: O(1).

Exercise: Get the final sorted linked list without duplicates in a single traversal of the two lists.
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!