Here, We see ** Intersection of Two Linked Lists problem Solution**. This Leetcode problem is done in many programming languages like C++, Java, JavaScript, Python, etc., with different approaches.

**Intersection of Two Linked Lists LeetCode Solution**

**Problem Statement ->**

Given the heads of two singly linked-lists ** headA** and

**, return**

*headB**the node at which the two lists intersect*. If the two linked lists have no intersection at all, return

**.**

*null*For example, the following two linked lists begin to intersect at node ** c1**:

The test cases are generated such that there are no cycles anywhere in the entire linked structure.

**Note** that the linked lists must **retain their original structure** after the function returns.

**Custom Judge:**

The inputs to the judge are given as follows (your program is not given these inputs):

– The value of the node where the intersection occurs. This is 0 if there is no intersected node.*intersectVal*– The first linked list.*listA*– The second linked list.*listB*– The number of nodes to skip ahead in listA (starting from the head) to get to the intersected node.*skipA*– The number of nodes to skip ahead in listB (starting from the head) to get to the intersected node.*skipB*

The judge will then create the linked structure based on these inputs and pass the two heads, ** headA **and

**to your program. If you correctly return the intersected node, then your solution will be**

*headB***accepted**.

Example 1:(fig-1)Input:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3Output:Intersected at '8'Explanation:The intersected node's value is 8 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,6,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B. - Note that the intersected node's value is not 1 because the nodes with value 1 in A and B (2nd node in A and 3rd node in B) are different node references. In other words, they point to two different locations in memory, while the nodes with value 8 in A and B (3rd node in A and 4th node in B) point to the same location in memory.

Example 2:(fig-2)Input:intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1Output:Intersected at '2'Explanation:The intersected node's value is 2 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [1,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.

Example 3:(fig-3)Input: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2Output: No intersectionExplanation: From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values. Explanation: The two lists do not intersect, so return null.

*Intersection of Two Linked Lists Leetcode Solution C++->*

*Intersection of Two Linked Lists Leetcode Solution C++->*

```
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
ListNode *ptr1 = headA;
ListNode *ptr2 = headB;
while(ptr1 != ptr2){
if(ptr1 == NULL){
ptr1 = headB;
}
else{
ptr1 = ptr1 -> next;
}
if(ptr2 == NULL){
ptr2 = headA;
}
else{
ptr2 = ptr2 -> next;
}
}
return ptr1;
}
};
```

Code language: C++ (cpp)

**Intersection of Two Linked Lists Leetcode Solution Java ->**

**Intersection of Two Linked Lists Leetcode Solution Java ->**

```
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode a = headA, b = headB;
while (a != b) {
a = a == null ? headB : a.next;
b = b == null ? headA : b.next;
}
return a;
}
}
```

Code language: Java (java)

**Intersection of Two Linked Lists Leetcode Solution JavaScript ->**

**Intersection of Two Linked Lists Leetcode Solution JavaScript ->**

```
var getIntersectionNode = function(headA, headB) {
if (!headA || !headB) {
return null;
}
let curA = headA;
let curB = headB;
while (curA !== curB) {
if (curA.next) {
curA = curA.next;
} else {
if (!curB.next) {
curA = null;
curB = null;
break;
}
curA = headB;
}
if (curB.next) {
curB = curB.next
} else {
curB = headA;
}
}
return curB;
};
```

Code language: JavaScript (javascript)

*Intersection of Two Linked Lists Leetcode Solution Python ->*

*Intersection of Two Linked Lists Leetcode Solution Python ->*

```
class Solution(object):
def getIntersectionNode(self, headA, headB):
curA,curB = headA,headB
lenA,lenB = 0,0
while curA is not None:
lenA += 1
curA = curA.next
while curB is not None:
lenB += 1
curB = curB.next
curA,curB = headA,headB
if lenA > lenB:
for i in range(lenA-lenB):
curA = curA.next
elif lenB > lenA:
for i in range(lenB-lenA):
curB = curB.next
while curB != curA:
curB = curB.next
curA = curA.next
return curA
```

Code language: Python (python)