POTD Solutions | 19 Nov' 23 | Intersection of two sorted linked lists

Note: The elements of the linked list are not necessarily distinct.

Examples:

Input: LinkedList1 = 1->2->3->4->6, LinkedList2 = 2->4->6->8
Output: 2 4 6
Explanation: For the given two linked list, 2, 4 and 6 are the elements in the intersection.

Input: LinkedList1 = 10->20->40->50, LinkedList2 = 15->40
Output: 40
Explanation: For the given two linked list, 40 is the element in the intersection.

Intersection of two sorted linked lists using Dummy Node:

The idea is to use a temporary dummy node at the start of the result list. The pointer tail always points to the last node in the result list, so new nodes can be added easily. The dummy node initially gives the tail a memory space to point to. This dummy node is efficient, since it is only temporary, and it is allocated in the stack. The loop proceeds, removing one node from either ‘a’ or ‘b’ and adding it to the tail. When the given lists are traversed the result is in dummy. next, as the values are allocated from next node of the dummy. If both the elements are equal then remove both and insert the element to the tail. Else remove the smaller element among both the lists. 

Below is the implementation of the above approach:

class Solution {
public:
    Node* findIntersection(Node* head1, Node* head2)
    {
        // code goes here.
        Node dummy(0);
        Node* tail = &dummy;
        dummy.next = NULL;

        /* Once one or the other
        list runs out -- we're done */
        while (head1 != NULL && head2 != NULL) {
            if (head1->data == head2->data) {
                tail->next = new Node(head1->data);
                tail = tail->next;
                head1 = head1->next;
                head2 = head2->next;
            }
            /* advance the smaller list */
            else if (head1->data < head2->data)
                head1 = head1->next;
            else
                head2 = head2->next;
        }
        return (dummy.next);
    }
};

class Solution {
    public static Node findIntersection(Node head1,
                                        Node head2)
    {
        // code here.
        // pointers for iterating
        Node p = head1, q = head2;
        Node tail = new Node(0);
        Node dummy = tail;
        while (p != null && q != null) {
            if (p.data == q.data) {
                // add to dummy list
                tail.next = new Node(p.data);
                tail = tail.next;
                p = p.next;
                q = q.next;
            }
            else if (p.data < q.data)
                p = p.next;
            else
                q = q.next;
        }
        return dummy.next;
    }
}

class Solution:
    def findIntersection(self, head1, head2):
        # return head
        dummy = Node(0)
        tail = dummy
        dummy.next = None

        ''' Once one or the other 
        list runs out -- we're done '''
        while (head1 != None and head2 != None):
            if (head1.data == head2.data):
                tail.next = Node(head1.data)
                tail = tail.next
                head1 = head1.next
                head2 = head2.next

            # advance the smaller list
            elif(head1.data < head2.data):
                head1 = head1.next
            else:
                head2 = head2.next
        return (dummy.next)