160-intersection-of-two-linked-lists.md Separated Chinese and English solutions.

gazeldx · gazeldx · commit ff743e2dc5ff · 2025-02-07T16:58:57.000+08:00
diff --git a/en/1-1000/160-intersection-of-two-linked-lists.md b/en/1-1000/160-intersection-of-two-linked-lists.md
@@ -1,10 +1,7 @@
 # 160. Intersection of Two Linked Lists - Best Practices of LeetCode Solutions
-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**.
 
-[中文题解](#中文题解)
-
-## LeetCode problem description
+## Description of "160. 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`.
 
 For example, the following two linked lists begin to intersect at node `c1`:
@@ -15,8 +12,6 @@ The test cases are generated such that there are **no cycles** anywhere in the e
 
 **Note** that the linked lists must **retain their original structure** after the function returns.
 
-Difficulty: **Easy**
-
 ### [Example 1]
 ![](../../images/examples/160_1.png)
 
@@ -25,6 +20,13 @@ Difficulty: **Easy**
 **Output**: `Intersected at '8'`
 
 ### [Example 2]
+![](../../images/examples/160_2.png)
+
+**Input**: `intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4]`
+
+**Output**: `Intersected at '2'`
+
+### [Example 3]
 ![](../../images/examples/160_3.png)
 
 **Input**: `listA = [2,6,4], listB = [1,5]`
@@ -40,8 +42,6 @@ Difficulty: **Easy**
 **Follow up**: Could you write a solution that runs in `O(m + n)` time and use only `O(1)` memory?
 
 ## Intuition
-[中文题解](#中文题解)
-
 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.
@@ -333,66 +333,3 @@ public class Solution
 ```
 // Welcome to create a PR to complete the code of this language, thanks!
 ```
-
-## 问题描述
-给你两个单链表的头节点 `headA` 和 `headB` ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 `null` 。
-
-图示两个链表在节点 `c1` 开始相交：
-
-![](../../images/examples/160.png)
-
-题目数据 **保证** 整个链式结构中**不存在环**。
-
-**注意**，函数返回结果后，链表必须 **保持其原始结构** 。
-
-难度: **容易**
-
-### [Example 1]
-![](../../images/examples/160_1.png)
-
-**输入**: `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`。
-```python
-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` 操作。
-```python
-bigger = headA
-smaller = headB
-
-if node_count_b > node_count_a:
-    bigger = headB
-    smaller = headA
-
-for _ in range(abs(node_count_b - node_count_a)):
-    bigger = bigger.next
-```
-
-3. 这时，两个链表同时重复进行`node = node.next`操作，直到找到相同的节点或者其中一个链表已经到尾部。
-```python
-while bigger and smaller:
-    if bigger == smaller:
-        return bigger
-
-    bigger = bigger.next
-    smaller = smaller.next
-
-return None
-```
diff --git a/zh/1-1000/160-intersection-of-two-linked-lists.md b/zh/1-1000/160-intersection-of-two-linked-lists.md
@@ -1,53 +1,53 @@
-# 160. Intersection of Two Linked Lists - Best Practices of LeetCode Solutions
-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. 相交链表 - 力扣题解最佳实践
+力扣链接：[160. 相交链表](https://leetcode.cn/problems/intersection-of-two-linked-lists), 难度: **简单**。
 
-[中文题解](#中文题解)
-
-## LeetCode problem description
-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`.
+## 力扣“160. 相交链表”问题描述
+给你两个单链表的头节点 `headA` 和 `headB` ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 `null` 。
 
-For example, the following two linked lists begin to intersect at node `c1`:
+图示两个链表在节点 `c1` 开始相交：
 
 ![](../../images/examples/160.png)
 
-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.
+题目数据 **保证** 整个链式结构中**不存在环**。
 
-Difficulty: **Easy**
+**注意**，函数返回结果后，链表必须 **保持其原始结构** 。
 
-### [Example 1]
+### [示例 1]
 ![](../../images/examples/160_1.png)
 
-**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'`
 
-### [Example 2]
-![](../../images/examples/160_3.png)
+### [示例 2]
+![](../../images/examples/160_2.png)
+
+**输入**: `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`
+### [示例 3]
+![](../../images/examples/160_3.png)
+
+**输入**: `listA = [2,6,4], listB = [1,5]`
 
-### [Constraints]
-- The number of nodes of `listA` is in the `m`.
-- The number of nodes of `listB` is in the `n`.
-- `1 <= m, n <= 3 * 10000`
-- `1 <= Node.val <= 100000`
+**输出**: `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`
+- `1 <= m, n <= 3 * 10**4`
+- `1 <= Node.val <= 10**5`
 
-## Intuition
-[中文题解](#中文题解)
+**进阶**：你能否设计一个时间复杂度 `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`操作，直到找到相同的节点或者其中一个链表已经到尾部。
 
-## Steps
-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`.
+## 步骤
+1. 先把A, B两个链表的节点数计算出来。链表A的节点数为`node_count_a`，链表B的节点数为`node_count_b`。
 ```python
 node_count_a = 0
 node_count_b = 0
@@ -58,7 +58,7 @@ while node:
     node = node.next
 ```
 
-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.
+2. 假如`node_count_b > node_count_a`，那么对链表B做`node_count_b - node_count_a`次`node = node.next` 操作。
 ```python
 bigger = headA
 smaller = headB
@@ -71,7 +71,7 @@ for _ in range(abs(node_count_b - node_count_a)):
     bigger = bigger.next
 ```
 
-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.
+3. 这时，两个链表同时重复进行`node = node.next`操作，直到找到相同的节点或者其中一个链表已经到尾部。
 ```python
 while bigger and smaller:
     if bigger == smaller:
@@ -83,9 +83,9 @@ while bigger and smaller:
 return None
 ```
 
-## Complexity
-* Time: `O(m + n)`.
-* Space: `O(1)`.
+## 复杂度
+* 时间：`O(m + n)`。
+* 空间：`O(1)`。
 
 ## Java
 ```java
@@ -333,66 +333,3 @@ public class Solution
 ```
 // Welcome to create a PR to complete the code of this language, thanks!
 ```
-
-## 问题描述
-给你两个单链表的头节点 `headA` 和 `headB` ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 `null` 。
-
-图示两个链表在节点 `c1` 开始相交：
-
-![](../../images/examples/160.png)
-
-题目数据 **保证** 整个链式结构中**不存在环**。
-
-**注意**，函数返回结果后，链表必须 **保持其原始结构** 。
-
-难度: **容易**
-
-### [Example 1]
-![](../../images/examples/160_1.png)
-
-**输入**: `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`。
-```python
-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` 操作。
-```python
-bigger = headA
-smaller = headB
-
-if node_count_b > node_count_a:
-    bigger = headB
-    smaller = headA
-
-for _ in range(abs(node_count_b - node_count_a)):
-    bigger = bigger.next
-```
-
-3. 这时，两个链表同时重复进行`node = node.next`操作，直到找到相同的节点或者其中一个链表已经到尾部。
-```python
-while bigger and smaller:
-    if bigger == smaller:
-        return bigger
-
-    bigger = bigger.next
-    smaller = smaller.next
-
-return None
-```
