LeetCode link:[160. Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists),

[160. 相交链表](https://leetcode.cn/problems/intersection-of-two-linked-lists)

LeetCode link:[160. Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists), difficulty:**Easy**.

[中文题解](#中文题解)

Given the heads of two singly linked-lists`headA` and`headB`, return_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`:

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

Difficulty:**Easy**

**Output**:`Intersected at '8'`

**Input**:`intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4]`

**Output**:`Intersected at '2'`

**Input**:`listA = [2,6,4], listB = [1,5]`

**Follow up**: Could you write a solution that runs in`O(m + n)` time and use only`O(1)` memory?

[中文题解](#中文题解)

1. First calculate the number of nodes in the two linked lists A and B. The number of nodes in linked list A is`node_count_a`, and the number of nodes in linked list B is`node_count_b`.

2. If`node_count_b > node_count_a`, then perform`node = node.next` for`node_count_b - node_count_a` times on linked list B.

3. At this time, repeat`node = node.next` on the two linked lists until the same node is found or one of the linked lists has reached the end.

给你两个单链表的头节点`headA` 和`headB` ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回`null` 。

图示两个链表在节点`c1` 开始相交：

题目数据**保证** 整个链式结构中**不存在环**。

**注意**，函数返回结果后，链表必须**保持其原始结构** 。

难度:**容易**

**输入**:`listA = [4,1,8,4,5], listB = [5,6,1,8,4,5]`

**输出**:`Intersected at '8'`

1. 先把A, B两个链表的节点数计算出来。链表A的节点数为`node_count_a`，链表B的节点数为`node_count_b`。

2. 假如`node_count_b > node_count_a`，那么对链表B做`node_count_b - node_count_a`次`node = node.next` 操作。

3. 这时，两个链表同时重复进行`node = node.next`操作，直到找到相同的节点或者其中一个链表已经到尾部。

1. 先把A, B两个链表的节点数计算出来。链表A的节点数为`node_count_a`，链表B的节点数为`node_count_b`。

node_count_a=0

node_count_b=0

node= headA

while node:

node_count_a+=1

node= node.next

2. 假如`node_count_b > node_count_a`，那么对链表B做`node_count_b - node_count_a`次`node = node.next` 操作。

bigger= headA

smaller= headB

if node_count_b> node_count_a:

bigger= headB

smaller= headA

for _inrange(abs(node_count_b- node_count_a)):

bigger= bigger.next

3. 这时，两个链表同时重复进行`node = node.next`操作，直到找到相同的节点或者其中一个链表已经到尾部。

while biggerand smaller:

if bigger== smaller:

return bigger

bigger= bigger.next

smaller= smaller.next

LeetCode link:[160. Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists),

[160. 相交链表](https://leetcode.cn/problems/intersection-of-two-linked-lists)

力扣链接：[160. 相交链表](https://leetcode.cn/problems/intersection-of-two-linked-lists), 难度:**简单**。

[中文题解](#中文题解)

Given the heads of two singly linked-lists`headA` and`headB`, return_the node at which the two lists intersect_. If the two linked lists have no intersection at all, return`null`.

给你两个单链表的头节点`headA` 和`headB` ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回`null` 。

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.

题目数据**保证** 整个链式结构中**不存在环**。

**Input**:`listA = [4,1,8,4,5], listB = [5,6,1,8,4,5]`

**输入**:`listA = [4,1,8,4,5], listB = [5,6,1,8,4,5]`

**Output**:`Intersected at '8'`

**输出**:`Intersected at '8'`

**输入**:`intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4]`

**Input**:`listA = [2,6,4], listB = [1,5]`

**输出**:`Intersected at '2'`

**Output**:`No intersection`

**输入**:`listA = [2,6,4], listB = [1,5]`

- The number of nodes of`listA` is in the`m`.

- The number of nodes of`listB` is in the`n`.

**输出**:`No intersection`

**Follow up**: Could you write a solution that runs in`O(m + n)` time and use only`O(1)` memory?

-`listA` 中节点数目为`m`

-`listB` 中节点数目为`n`

[中文题解](#中文题解)

**进阶**：你能否设计一个时间复杂度`O(m + n)` 、仅用`O(1)` 内存的解决方案？

1. First calculate the number of nodes in the two linked lists A and B. The number of nodes in linked list A is`node_count_a`, and the number of nodes in linked list B is`node_count_b`.

2. If`node_count_b > node_count_a`, then perform`node = node.next` for`node_count_b - node_count_a` times on linked list B.

3. At this time, repeat`node = node.next` on the two linked lists until the same node is found or one of the linked lists has reached the end.

1. 先把A, B两个链表的节点数计算出来。链表A的节点数为`node_count_a`，链表B的节点数为`node_count_b`。

2. 假如`node_count_b > node_count_a`，那么对链表B做`node_count_b - node_count_a`次`node = node.next` 操作。

3. 这时，两个链表同时重复进行`node = node.next`操作，直到找到相同的节点或者其中一个链表已经到尾部。

node_count_a=0

node_count_b=0

node= node.next

bigger= headA

smaller= headB

bigger= bigger.next

while biggerand smaller:

if bigger== smaller:

给你两个单链表的头节点`headA` 和`headB` ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回`null` 。

图示两个链表在节点`c1` 开始相交：

题目数据**保证** 整个链式结构中**不存在环**。

**注意**，函数返回结果后，链表必须**保持其原始结构** 。

难度:**容易**

**输入**:`listA = [4,1,8,4,5], listB = [5,6,1,8,4,5]`

**输出**:`Intersected at '8'`

1. 先把A, B两个链表的节点数计算出来。链表A的节点数为`node_count_a`，链表B的节点数为`node_count_b`。

2. 假如`node_count_b > node_count_a`，那么对链表B做`node_count_b - node_count_a`次`node = node.next` 操作。

3. 这时，两个链表同时重复进行`node = node.next`操作，直到找到相同的节点或者其中一个链表已经到尾部。

1. 先把A, B两个链表的节点数计算出来。链表A的节点数为`node_count_a`，链表B的节点数为`node_count_b`。

node_count_a=0

node_count_b=0

node= headA

while node:

node_count_a+=1

node= node.next

2. 假如`node_count_b > node_count_a`，那么对链表B做`node_count_b - node_count_a`次`node = node.next` 操作。

bigger= headA

smaller= headB

if node_count_b> node_count_a:

bigger= headB

smaller= headA

for _inrange(abs(node_count_b- node_count_a)):

bigger= bigger.next

3. 这时，两个链表同时重复进行`node = node.next`操作，直到找到相同的节点或者其中一个链表已经到尾部。

while biggerand smaller:

if bigger== smaller:

return bigger

bigger= bigger.next

smaller= smaller.next