Merge two sorted linked list without duplicates

// Java implementation to merge two sorted linked list
// without duplicates
import java.io.*;

class GFG {

    // structure of a node
    class Node {
        int data;
        Node next;
    }

    // function to get a new node
    public Node getNode(int data)
    {
        Node temp = new Node();
        temp.data = data;
        temp.next = null;
        return temp;
    }

    // function to merge two sorted linked list in a sorted
    // manner
    static Node sortedMerge(Node a, 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 */
    static 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;
                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
    public 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
    public void printList(Node head)
    {
        while (head != null) {
            System.out.print(head.data + " ");
            head = head.next;
        }
    }

    public static void main(String[] args)
    {

        GFG l = new GFG();

        // head1 : 1->1->4->5->7
        Node head1 = l.getNode(1);
        head1.next = l.getNode(1);
        head1.next.next = l.getNode(4);
        head1.next.next.next = l.getNode(5);
        head1.next.next.next.next = l.getNode(7);

        // head2 : 2->4->7->9
        Node head2 = l.getNode(2);
        head2.next = l.getNode(4);
        head2.next.next = l.getNode(7);
        head2.next.next.next = l.getNode(9);

        Node head3;

        head3
            = l.sortedMergeWithoutDuplicates(head1, head2);

        l.printList(head3);
    }
}

// This code is contributed by lokeshmvs21.

public class Main {

    // Node class to represent a node in the linked list
    static class Node {
        int data;
        Node next;

        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    // Function to merge two sorted linked lists without duplicates
    static Node sortedMergeWithoutDuplicates(Node head1, Node head2) {
        // Create a dummy node to simplify merging
        Node dummy = new Node(-1);
        Node tail = dummy;

        // Merge the two sorted linked lists
        while (head1 != null && head2 != null) {
            if (head1.data < head2.data) {
                // Append the smaller node to the merged list
                tail.next = head1;
                head1 = head1.next;
            } else if (head1.data > head2.data) {
                // Append the smaller node to the merged list
                tail.next = head2;
                head2 = head2.next;
            } else {
                // If both nodes have the same value, 
                // append only one of them to avoid duplicates
                tail.next = head1;
                head1 = head1.next;
                head2 = head2.next;
            }
            tail = tail.next;
            tail.next = null; // Mark the end of the merged list
        }

        // If any elements left in either of the lists, add them to the merged list
        if (head1 != null) {
            tail.next = head1;
        }
        if (head2 != null) {
            tail.next = head2;
        }

        // Remove duplicates from the merged list
        Node current = dummy.next;
        while (current != null && current.next != null) {
            if (current.data == current.next.data) {
                // Remove the duplicate node from the merged list
                Node temp = current.next;
                current.next = current.next.next;
                temp = null; // Free the memory of the duplicate node
            } else {
                // Move to the next node
                current = current.next;
            }
        }

        return dummy.next;
    }

    // Function to print a linked list
    static void printList(Node head) {
        // Traverse the linked list and print its elements
        while (head != null) {
            System.out.print(head.data + " ");
            head = head.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // Create two sorted linked lists
        Node head1 = new Node(1);
        head1.next = new Node(1);
        head1.next.next = new Node(4);
        head1.next.next.next = new Node(5);
        head1.next.next.next.next = new Node(7);

        Node head2 = new Node(2);
        head2.next = new Node(4);
        head2.next.next = new Node(7);
        head2.next.next.next = new Node(9);

        // Merge the two lists without duplicates and print the result
        Node head3 = sortedMergeWithoutDuplicates(head1, head2);
        printList(head3);
    }
}
// This code is contributed by rambabuguphka