Related Articles

# Intersection point of two Linked Lists | Set 3

• Last Updated : 05 Jul, 2021

Given two linked lists of size N and M consisting of positive value nodes, having a common intersection point, the task is to find the intersection point of the two linked lists where they merge.

Examples:

Input: L1: 3 → 6 → 9 → 15 → 30, L2: 10 → 15 → 30
Output: 15
Explanation: From the above image, the intersection point of the two linked lists is 15.

Input: L1: 1 → 2 → 3, L2: 4 → 5 → 1 → 2 → 3
Output: 1

Approach: The idea is to traverse the first linked list and multiply the value of each node by -1 thus making them negative. Then, traverse the second linked list and print the value of the first node having a negative value. Follow the steps below to solve the problem:

• Traverse the first linked list L1 and multiply the value of each node by -1.
• Now, traverse the second linked list L2 and if there exists any node with negative values then print the absolute value of the node’s value as the resultant intersection of the linked list and break out of the loop.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Structure of a node``// of a Linked List``class` `Node {``public``:``    ``int` `data;``    ``Node* next;` `    ``// Constructor``    ``Node(``int` `x)``    ``{``        ``data = x;``        ``next = NULL;``    ``}``};` `// Function to find the intersection``// point of the two Linked Lists``Node* intersectingNode(Node* headA,``                       ``Node* headB)``{` `    ``// Traverse the first linked list``    ``// and multiply all values by -1``    ``Node* a = headA;` `    ``while` `(a) {` `        ``// Update a -> data``        ``a->data *= -1;` `        ``// Update a``        ``a = a->next;``    ``}` `    ``// Traverse the second Linked List``    ``// and find the value of the first``    ``// node having negative value``    ``Node* b = headB;` `    ``while` `(b) {` `        ``// Intersection point``        ``if` `(b->data < 0)``            ``break``;` `        ``// Update b``        ``b = b->next;``    ``}` `    ``return` `b;``}` `// Function to create linked lists``void` `formLinkList(Node*& head1,``                  ``Node*& head2)``{``    ``// Linked List L1``    ``head1 = ``new` `Node(3);``    ``head1->next = ``new` `Node(6);``    ``head1->next->next = ``new` `Node(9);``    ``head1->next->next->next = ``new` `Node(15);``    ``head1->next->next->next->next = ``new` `Node(30);` `    ``// Linked List L2``    ``head2 = ``new` `Node(10);``    ``head2->next = head1->next->next->next;` `    ``return``;``}` `// Driver Code``int` `main()``{``    ``Node* head1;``    ``Node* head2;``    ``formLinkList(head1, head2);` `    ``cout << ``abs``(intersectingNode(head1,``                                 ``head2)``                    ``->data);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG{``    ` `static` `Node head1 = ``null``;``static` `Node head2 = ``null``;` `// Structure of a node``// of a Linked List``static` `class` `Node``{``    ``int` `data;``    ``Node next;` `    ``// Constructor``    ``Node(``int` `x)``    ``{``        ``data = x;``        ``next = ``null``;``    ``}``}` `// Function to find the intersection``// point of the two Linked Lists``static` `Node intersectingNode(Node headA, Node headB)``{``    ` `    ``// Traverse the first linked list``    ``// and multiply all values by -1``    ``Node a = headA;` `    ``while` `(a != ``null``)``    ``{``        ` `        ``// Update a -> data``        ``a.data *= -``1``;` `        ``// Update a``        ``a = a.next;``    ``}` `    ``// Traverse the second Linked List``    ``// and find the value of the first``    ``// node having negative value``    ``Node b = headB;` `    ``while` `(b != ``null``)``    ``{``        ` `        ``// Intersection point``        ``if` `(b.data < ``0``)``            ``break``;` `        ``// Update b``        ``b = b.next;``    ``}``    ``return` `b;``}` `// Function to create linked lists``static` `void` `formLinkList()``{``    ` `    ``// Linked List L1``    ``head1 = ``new` `Node(``3``);``    ``head1.next = ``new` `Node(``6``);``    ``head1.next.next = ``new` `Node(``9``);``    ``head1.next.next.next = ``new` `Node(``15``);``    ``head1.next.next.next.next = ``new` `Node(``30``);` `    ``// Linked List L2``    ``head2 = ``new` `Node(``10``);``    ``head2.next = head1.next.next.next;` `    ``return``;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``formLinkList();` `    ``System.out.println(Math.abs(``        ``intersectingNode(head1, head2).data));``}``}` `// This code is contributed by Dharanendra L V.`

## Python3

 `# Python3 program for the above approach` `# Structure of a node``# of a Linked List``class` `Node:``    ` `    ``def` `__init__(``self``, d):``        ` `        ``self``.data ``=` `d``        ``self``.``next` `=` `None` `# Function to find the intersection``# point of the two Linked Lists``def` `intersectingNode(headA, headB):` `    ``# Traverse the first linked list``    ``# and multiply all values by -1``    ``a ``=` `headA` `    ``while` `(a):` `        ``# Update a . data``        ``a.data ``*``=` `-``1` `        ``# Update a``        ``a ``=` `a.``next` `    ``# Traverse the second Linked List``    ``# and find the value of the first``    ``# node having negative value``    ``b ``=` `headB` `    ``while` `(b):` `        ``# Intersection point``        ``if` `(b.data < ``0``):``            ``break` `        ``# Update b``        ``b ``=` `b.``next` `    ``return` `b` `# Function to create linked lists``def` `formLinkList(head1, head2):``    ` `    ``# Linked List L1``    ``head1 ``=` `Node(``3``)``    ``head1.``next` `=` `Node(``6``)``    ``head1.``next``.``next` `=` `Node(``9``)``    ``head1.``next``.``next``.``next` `=` `Node(``15``)``    ``head1.``next``.``next``.``next``.``next` `=` `Node(``30``)` `    ``# Linked List L2``    ``head2 ``=` `Node(``10``)``    ``head2.``next` `=` `head1.``next``.``next``.``next` `    ``return` `head1, head2` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``head1, head2 ``=` `formLinkList(``None``, ``None``)` `    ``print``(``abs``(intersectingNode(head1, head2).data))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach` `using` `System;` `public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node next;`` ` `    ``// Constructor``    ``public` `Node(``int` `x)``    ``{``        ``data = x;``        ``next = ``null``;``    ``}``}` `public` `class` `GFG{``    ` `    ``static` `Node head1 = ``null``;``static` `Node head2 = ``null``;``// Function to find the intersection``// point of the two Linked Lists``static` `Node intersectingNode(Node headA, Node headB)``{``     ` `    ``// Traverse the first linked list``    ``// and multiply all values by -1``    ``Node a = headA;`` ` `    ``while` `(a != ``null``)``    ``{``         ` `        ``// Update a -> data``        ``a.data *= -1;`` ` `        ``// Update a``        ``a = a.next;``    ``}`` ` `    ``// Traverse the second Linked List``    ``// and find the value of the first``    ``// node having negative value``    ``Node b = headB;`` ` `    ``while` `(b != ``null``)``    ``{``         ` `        ``// Intersection point``        ``if` `(b.data < 0)``            ``break``;`` ` `        ``// Update b``        ``b = b.next;``    ``}``    ``return` `b;``}`` ` `// Function to create linked lists``static` `void` `formLinkList()``{``     ` `    ``// Linked List L1``    ``head1 = ``new` `Node(3);``    ``head1.next = ``new` `Node(6);``    ``head1.next.next = ``new` `Node(9);``    ``head1.next.next.next = ``new` `Node(15);``    ``head1.next.next.next.next = ``new` `Node(30);`` ` `    ``// Linked List L2``    ``head2 = ``new` `Node(10);``    ``head2.next = head1.next.next.next;`` ` `    ``return``;``}`` ` `// Driver Code``    ` `    ``static` `public` `void` `Main ()``    ``{``        ` `        ``formLinkList();`` ` `    ``Console.WriteLine(Math.Abs(``        ``intersectingNode(head1, head2).data));``        ` `    ``}``}` `// This code is contributed by unknown2108.`

## Javascript

 ``
Output:
`15`

Time Complexity: O(N + M)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up