# Intersection of two single linked lists in java

[title]
If the two linked lists intersect, the first node of the intersection is returned. If they do not intersect, null is returned
[requirements]
If the total length of the two linked lists is N, the time complexity is O(N) and the space complexity is O(1)
[ideas]
The two single linked lists are divided into the following three cases. In fact, only 1 and 3 need to be considered

1.1. Intersection
1.2. Disjoint
2. Two single linked lists, one acyclic and one ring - can't intersect
3. Two single linked lists have rings
3.1 intersect outside the ring
3.2 intersecting in the ring
3.3 Disjoint

1. Judge whether the linked list has a ring and use the speed pointer
The fast pointer takes two steps at a time and the slow pointer takes one step at a time
If there is a ring, the two pointers will eventually meet. The fast pointer returns to the beginning. The fast pointer and slow pointer one node at a time. The node that meets again is the ring entry node. Just return to the ring entry node

If there is no ring, the next node or the next node of the fast pointer must be empty. Return null

```public Node getLoopNode(Node head){
//Less than 3 nodes are acyclic
return null;
}
//Get the intersection of fast and slow pointers
while (fast != slow){

//The node finally points to null, indicating acyclic
if (fast.next == null || fast.next.next == null){
return null;
}
fast = fast.next.next;
slow = slow.next;
}
//The fast pointer returns to the beginning and moves at the same time as the slow pointer. Each time a node intersects, the intersection position is the ring entry point. Prove yourself to check
while (slow != fast){
slow = slow.next;
fast = fast.next;
}
return slow;
}
```
1. Judge whether it is a linked list by whether the incoming node is empty
2.1 both are acyclic linked lists. First traverse the length of the two linked lists. The length difference is dif. For the longer linked list, go through dif nodes first, and then start to go through the long and short linked lists at the same time. When you reach the same node, it is the first intersection node. If there are no equal nodes, it means no intersection
```private Node getNoLoopNode(Node head1,Node head2){
return null;
}
//Traverse two linked lists to obtain the length difference
int len = 0;
while (null != cur1){
len++;
cur1 = cur1.next;
}
while (null != cur2){
len--;
cur2 = cur2.next;
}

len = Math.abs(len);
while (len != 0){
len--;
cur1 = cur1.next;
}
while (cur1 != cur2){
cur1 = cur1.next;
cur2 = cur2.next;
}
return cur1;
}
```

2.2 there are all linked lists. There are three cases,

• Intersect outside the ring
If the nodes in the ring are the same, it means that they intersect outside the ring. The method of obtaining intersection nodes is the same as that of acyclic single linked list
• They don't intersect
If the incoming nodes are not connected, use the characteristics of whether the incoming nodes continue to traverse whether they meet to judge whether they intersect in the ring. If they do not meet, it means they do not intersect
• Intersect on ring
If the entry node continues to traverse and meet, it indicates that it intersects on the ring
```private Node getBothLoopNode(Node head1, Node loop1, Node head2, Node loop2){
Node cur1 = null;
Node cur2 = null;
//If the exchange nodes of two linked lists are the same, they must intersect outside the ring. The intersection nodes are obtained in the way of single linked list acyclic
if (loop1 == loop2){
int len = 0;
while (cur1 != loop1){
len++;
cur1 = cur1.next;
}
while (cur2 != loop2){
len--;
cur2 = cur2.next;
}
len = Math.abs(len);
while (len != 0){
cur1 = cur1.next;
len--;
}
while (cur1 != cur2){
cur1 = cur1.next;
cur2 = cur2.next;
}
return cur1;
} else {
cur1 = loop1.next;
//Traverse the ring nodes. If they meet, they intersect on the ring, otherwise they do not intersect
while (cur1 != loop1){
if (cur1 == loop2){
return loop1;//loop1  or loop2
}
cur1 = cur1.next;
}
return null;
}
}
```

On this topic, it is mainly clear that each node of the single linked list has only one direction. If you enter the ring, you will not leave the ring

Posted on Thu, 14 Oct 2021 22:34:00 -0400 by Weirdan