Updated format.

gazeldx · gazeldx · commit cd5daa60dca5 · 2025-03-11T09:21:49.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
@@ -36,52 +36,63 @@ The test cases are generated such that there are **no cycles** anywhere in the e
 ### [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`
+- `1 <= m, n <= 3 * 10^4`
+- `1 <= Node.val <= 10^5`
 
 **Follow up**: Could you write a solution that runs in `O(m + n)` time and use only `O(1)` memory?
 
 ## Intuition
+This is a typical "encounter" problem, and it is best to transform it into a real-life scenario to enhance understanding.
+
+Suppose you are A, and you are pursuing B. The destination is school. On the way to school, the distance at the back is what you both have to go through, and the distance at the front is for each of you to go your own way. The node spacing is assumed to be one kilometer.
+
+Now, one morning, you both finished breakfast at the same time and are going to ride your bike to school. And you have a goal: to meet B and chat with him/her for a few words. What will you do? (Take Example 1 as an example)
+
+You must first calculate how many kilometers her home is farther from the school than your home, and then wait for her to walk these kilometers before setting off. As long as you have the same speed, you will definitely meet, and the node where you meet is the answer.
+
 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.
 
 ## 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`.
-```python
-node_count_a = 0
-node_count_b = 0
 
-node = headA
-while node:
-    node_count_a += 1
-    node = node.next
-```
+	```python
+	node_count_a = 0
+	node_count_b = 0
+	
+	node = headA
+	while node:
+	    node_count_a += 1
+	    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.
-```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
-```
+	```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. 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.
-```python
-while bigger and smaller:
-    if bigger == smaller:
-        return bigger
 
-    bigger = bigger.next
-    smaller = smaller.next
-
-return None
-```
+	```python
+	while bigger and smaller:
+	    if bigger == smaller:
+	        return bigger
+	
+	    bigger = bigger.next
+	    smaller = smaller.next
+	
+	return None
+	```
 
 ## Complexity
 * Time: `O(m + n)`.
diff --git a/en/1-1000/203-remove-linked-list-elements.md b/en/1-1000/203-remove-linked-list-elements.md
@@ -237,7 +237,7 @@ def remove_elements(head, val)
   dummy_head.next = head
   node = dummy_head
 
-  while !node.next.nil?
+  until node.next.nil?
     if node.next.val == val
       node.next = node.next.next
     else
diff --git a/en/1-1000/206-reverse-linked-list.md b/en/1-1000/206-reverse-linked-list.md
@@ -28,45 +28,55 @@ Given the `head` of a singly linked list, reverse the list, and return _the reve
 - `-5000 <= Node.val <= 5000`
 
 ## Intuition
-1. To solve this problem, we only need to define **two** variables: `current` and `previous`.
-2. `current.next = previous` is the inversion.
-3. The loop condition should be `while (current != null)` instead of `while (current.next != null)`, because the operation to be performed is `current.next = previous`.
+1. To solve this problem, we only need to define **two** variables: `current` and `previous`. How do we inverse two node?
+
+	<details>
+	  <summary>
+	  Click to view the answer.
+	  </summary>
+	  <p>`current.next = previous` is the inversion.</p>
+	</details>
+
+2. The loop condition should be `while (current != null)` instead of `while (current.next != null)`, because the operation to be performed is `current.next = previous`.
 
 ## Steps
 1. Traverse all nodes.
-```javascript
-previous = null
-current = head
 
-while (current != null) {
-    current = current.next
-}
-```
+	```javascript
+	previous = null
+	current = head
+	
+	while (current != null) {
+	    current = current.next
+	}
+	```
 
 2. Add `current.next = previous`.
-```javascript
-previous = null
-current = head
 
-while (current != null) {
-    tempNext = current.next
-    current.next = previous
-    current = tempNext
-}
-```
+	```javascript
+	previous = null
+	current = head
+	
+	while (current != null) {
+	    tempNext = current.next
+	    current.next = previous
+	    current = tempNext
+	}
+	```
 
 3. `previous` is always `null`, we need to change it: `previous = current`.
-```javascript
-previous = null
-current = head
 
-while (current != null) {
-    tempNext = current.next
-    current.next = previous
-    previous = current
-    current = tempNext
-}
-```
+	```javascript
+	previous = null
+	current = head
+	
+	while (current != null) {
+	    tempNext = current.next
+	    current.next = previous
+	    previous = current
+	    current = tempNext
+	}
+	```
 
 ## Complexity
 * Time: `O(n)`.
diff --git a/zh/1-1000/160-intersection-of-two-linked-lists.md b/zh/1-1000/160-intersection-of-two-linked-lists.md
@@ -42,46 +42,57 @@
 **进阶**：你能否设计一个时间复杂度 `O(m + n)` 、仅用 `O(1)` 内存的解决方案？
 
 ## 思路
+这是一个典型的“相遇”问题，最好转化为现实的场景去加强理解。
+
+假设你是A，B是你追求的对象，终点是学校。在上学的路上，靠后面的路程是你们都要经过的，靠前面的路程是各走各的。节点间距假定为一公里。
+
+现在，某个早晨，你们同时都吃完了早饭，要骑车去学校了。而你有个目标：和B相遇，聊上几句，你会怎么做？(以示例一为例)
+
+你一定是先测算出她家比你家到学校远多少公里，然后**等她走完这些公里后，再出发**。只要你们速度相同，就一定能相遇，而相遇的节点就是答案。
+
 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
-```
+	```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
-```
+	```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
-```
+	```python
+	while bigger and smaller:
+	    if bigger == smaller:
+	        return bigger
+	
+	    bigger = bigger.next
+	    smaller = smaller.next
+	
+	return None
+	```
 
 ## 复杂度
 * 时间：`O(m + n)`。
diff --git a/zh/1-1000/203-remove-linked-list-elements.md b/zh/1-1000/203-remove-linked-list-elements.md
@@ -235,7 +235,7 @@ def remove_elements(head, val)
   dummy_head.next = head
   node = dummy_head
 
-  while !node.next.nil?
+  until node.next.nil?
     if node.next.val == val
       node.next = node.next.next
     else
diff --git a/zh/1-1000/206-reverse-linked-list.md b/zh/1-1000/206-reverse-linked-list.md
@@ -29,44 +29,54 @@
 
 ## 思路
 1. 解决这个问题，只需要定义**两**个变量：`current`和`previous`。
-2. `current.next = previous`就是反转了。
-3. 循环条件应是`while (current != null)`，而不应该是`while (current.next != null)`，因为需要操作的是`current.next = previous`.
+
+	<details>
+	  <summary>
+	  点击查看答案
+	  </summary>
+	  <p>`current.next = previous`就是反转了。</p>
+	</details>
+
+2. 循环条件应是`while (current != null)`，而不应该是`while (current.next != null)`，因为需要操作的是`current.next = previous`.
 
 ## 步骤
 1. 遍历所有节点。
-```javascript
-previous = null
-current = head
 
-while (current != null) {
-    current = current.next
-}
-```
+	```javascript
+	previous = null
+	current = head
+	
+	while (current != null) {
+	    current = current.next
+	}
+	```
 
 2. 加入`current.next = previous`。
-```javascript
-previous = null
-current = head
 
-while (current != null) {
-    tempNext = current.next
-    current.next = previous
-    current = tempNext
-}
-```
+	```javascript
+	previous = null
+	current = head
+	
+	while (current != null) {
+	    tempNext = current.next
+	    current.next = previous
+	    current = tempNext
+	}
+	```
 
 3. `previous`目前始终是`null`，需要让它变化起来：`previous = current`。
-```javascript
-previous = null
-current = head
 
-while (current != null) {
-    tempNext = current.next
-    current.next = previous
-    previous = current
-    current = tempNext
-}
-```
+	```javascript
+	previous = null
+	current = head
+	
+	while (current != null) {
+	    tempNext = current.next
+	    current.next = previous
+	    previous = current
+	    current = tempNext
+	}
+	```
 
 ## 复杂度
 * 时间：`O(N)`。
