24-swap-nodes-in-pairs.md Separated Chinese and English solutions.

gazeldx · gazeldx · commit eae893408836 · 2025-02-01T09:01:24.000+08:00
diff --git a/en/1-1000/24-swap-nodes-in-pairs.md b/en/1-1000/24-swap-nodes-in-pairs.md
@@ -1,10 +1,7 @@
 # 24. Swap Nodes in Pairs - Best Practices of LeetCode Solutions
-LeetCode link: [24. Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs),
-[24. 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs)
+LeetCode link: [24. Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs), difficulty: **Medium**
 
-[中文题解](#中文题解)
-
-## LeetCode problem description
+## Description of "24. Swap Nodes in Pairs"
 Given a linked list, swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)
 
 ### [Example 1]
@@ -34,14 +31,12 @@ Given a linked list, swap every two adjacent nodes and return its head. You must
 - `0 <= Node.val <= 100`
 
 ## Intuition
-[中文题解](#中文题解)
-
 Before solving this problem, it is recommended to solve the simple problem [206. Reverse Linked List](206-reverse-linked-list.md) first.
 
 1. To solve this problem, you still need to define at least two variables: `current` and `previous`.
 2. The loop condition should be `while (current.next != null)` instead of `while (current != null)`, because the operations that need to be performed include `current.next.next`.
 
-## Steps to the Solution
+## Steps
 1. Traverse all nodes.
 ```c#
 var previous = null;
@@ -369,96 +364,3 @@ end
 ```
 // Welcome to create a PR to complete the code of this language, thanks!
 ```
-
-## 问题描述
-给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
-
-### [Example 1]
-![](../../images/examples/24_1.jpg)
-
-**输入**: `head = [1,2,3,4]`
-
-**输出**: `[2,1,4,3]`
-
-## 中文题解
-### 思路
-在做本题前，建议先完成简单题目[206. Reverse Linked List](206-reverse-linked-list.md)。
-
-1. 解决这个问题，依然至少需要定义两个变量：`current`和`previous`。
-2. 循环条件应是`while (current.next != null)`，而不应该是`while (current != null)`，因为需要操作`current.next.next`.
-
-### 步骤
-1. 遍历所有节点。
-```java
-var previous = null;
-var current = head;
-
-while (current != null) {
-    current = current.next;
-}
-```
-
-2. 因为每两个节点进行一次位置互换，所以需要改为一次走两步。
-```java
-var previous = null;
-var current = head;
-
-while (current != null && current.next != null) { // 1
-    var nextNext = current.next.next; // 2
-    current = nextNext; // 3
-}
-```
-
-3. 交换 `current` 和 `current.next` 的位置。
-```java
-var previous = null;
-var current = head;
-
-while (current != null && current.next != null) {
-    var nextNext = current.next.next;
-
-    current.next.next = current; // 1
-    current.next = nextNext; // 2
-
-    current = nextNext;
-}
-```
-
-4. 处理 `previous`。
-```java
-var previous = null;
-var current = head;
-
-while (current != null && current.next != null) {
-    var nextNext = current.next.next;
-
-    previous.next = current.next; // 1
-    current.next.next = current;
-    current.next = nextNext;
-
-    previous = current; // 2
-    current = nextNext;
-}
-```
-
-5. 确定返回值。因为`head`节点在节点数量超过1时，会被交换到第二个节点的位置，为了统一方便处理，最好加入`dummy_head`节点。
-```java
-var dummyHead = new ListNode(); // 1
-dummyHead.next = head; // 2
-
-var previous = dummyHead; // 3
-var current = head;
-
-while (current != null && current.next != null) {
-    var nextNext = current.next.next;
-
-    previous.next = current.next;
-    current.next.next = current;
-    current.next = nextNext;
-
-    previous = current;
-    current = nextNext;
-}
-
-return dummyHead.next; // 4
-```
diff --git a/en/3001-4000/unorganized.md b/en/3001-4000/unorganized.md
@@ -107,7 +107,19 @@ The improved way with a queue is commonly more efficient. Relaxing **All Edges**
 - 530 https://leetcode.cn/problems/minimum-absolute-difference-in-bst/
     783 https://leetcode.com/problems/minimum-distance-between-bst-nodes/ is the same
 - 501 https://leetcode.cn/problems/find-mode-in-binary-search-tree/
+- 701 https://leetcode.cn/problems/insert-into-a-binary-search-tree/ Carl's solution is shorter, but may hard to understand and think about
+- 450 https://leetcode.cn/problems/delete-node-in-a-bst/ Carl's solution is shorter
+- 669 https://leetcode.cn/problems/trim-a-binary-search-tree/description/
+- 108 https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/
+- 538 https://leetcode.cn/problems/convert-bst-to-greater-tree/
+
+### Backtracking
+- 77 https://leetcode.cn/problems/combinations/description/
+- 216 https://leetcode.cn/problems/combination-sum-iii/
+- 17 https://leetcode.cn/problems/letter-combinations-of-a-phone-number/
+- 39 https://leetcode.cn/problems/combination-sum/
 - 
+
 ### Failed in 2 rounds
 - 222 https://leetcode.cn/problems/count-complete-tree-nodes/
 - 236 https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/
diff --git a/zh/1-1000/24-swap-nodes-in-pairs.md b/zh/1-1000/24-swap-nodes-in-pairs.md
@@ -1,48 +1,38 @@
-# 24. Swap Nodes in Pairs - Best Practices of LeetCode Solutions
-LeetCode link: [24. Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs),
-[24. 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs)
+# 24. 两两交换链表中的节点 - 力扣题解最佳实践
+力扣链接：[24. 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs), 难度: **中等**。
 
-[中文题解](#中文题解)
-
-## LeetCode problem description
-Given a linked list, swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)
+## 力扣“24. 两两交换链表中的节点”问题描述
+给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
 
-### [Example 1]
+### [示例 1]
 ![](../../images/examples/24_1.jpg)
 
-**Input**: `head = [1,2,3,4]`
-
-**Output**: `[2,1,4,3]`
-
-### [Example 2]
-**Input**: `head = []`
+**输入**: `head = [1,2,3,4]`
 
-**Output**: `[]`
+**输出**: `[2,1,4,3]`
 
-### [Example 3]
-**Input**: `head = [1]`
+### [示例 2]
+**输入**: `head = []`
 
-**Output**: `[1]`
+**输出**: `[]`
 
-### [Example 4]
-**Input**: `head = [1,2,3]`
+### [示例 3]
+**输入**: `head = [1]`
 
-**Output**: `[2,1,3]`
+**输出**: `[1]`
 
-### [Constraints]
-- The number of nodes in the list is in the range `[0, 100]`.
+### [约束]
+- 链表中节点的数目在范围 `[0, 100]` 内
 - `0 <= Node.val <= 100`
 
-## Intuition
-[中文题解](#中文题解)
-
-Before solving this problem, it is recommended to solve the simple problem [206. Reverse Linked List](206-reverse-linked-list.md) first.
+## 思路
+在做本题前，建议先完成简单题目[206. Reverse Linked List](206-reverse-linked-list.md)。
 
-1. To solve this problem, you still need to define at least two variables: `current` and `previous`.
-2. The loop condition should be `while (current.next != null)` instead of `while (current != null)`, because the operations that need to be performed include `current.next.next`.
+1. 解决这个问题，依然至少需要定义两个变量：`current`和`previous`。
+2. 循环条件应是`while (current.next != null)`，而不应该是`while (current != null)`，因为需要操作`current.next.next`.
 
-## Steps to the Solution
-1. Traverse all nodes.
+## 步骤
+1. 遍历所有节点。
 ```c#
 var previous = null;
 var current = head;
@@ -52,7 +42,7 @@ while (current != null) {
 }
 ```
 
-2. Because every two nodes swap positions, it is necessary to change it to taking two steps at a time.
+2. 因为每两个节点进行一次位置互换，所以需要改为一次走两步。
 ```c#
 var previous = null;
 var current = head;
@@ -63,7 +53,7 @@ while (current != null && current.next != null) { // 1
 }
 ```
 
-3. Swap the positions of `current` and `current.next`.
+3. 交换 `current` 和 `current.next` 的位置。
 ```c#
 var previous = null;
 var current = head;
@@ -78,7 +68,7 @@ while (current != null && current.next != null) {
 }
 ```
 
-4. Process `previous`.
+4. 处理 `previous`。
 ```c#
 var previous = null;
 var current = head;
@@ -95,7 +85,7 @@ while (current != null && current.next != null) {
 }
 ```
 
-5. Determine the return value. Because the `head` node will be swapped to the second node when the number of nodes exceeds 1, it is best to add a `dummy_head` node for unified and convenient processing.
+5. 确定返回值。因为`head`节点在节点数量超过1时，会被交换到第二个节点的位置，为了统一方便处理，最好加入`dummy_head`节点。
 ```c#
 var dummyHead = new ListNode(); // 1
 dummyHead.next = head; // 2
@@ -117,9 +107,9 @@ while (current != null && current.next != null) {
 return dummyHead.next; // 4
 ```
 
-## Complexity
-* Time: `O(n)`.
-* Space: `O(1)`.
+## 复杂度
+* 时间: `O(n)`。
+* 空间: `O(1)`。
 
 ## Java
 ```java
@@ -369,96 +359,3 @@ end
 ```
 // Welcome to create a PR to complete the code of this language, thanks!
 ```
-
-## 问题描述
-给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
-
-### [Example 1]
-![](../../images/examples/24_1.jpg)
-
-**输入**: `head = [1,2,3,4]`
-
-**输出**: `[2,1,4,3]`
-
-## 中文题解
-### 思路
-在做本题前，建议先完成简单题目[206. Reverse Linked List](206-reverse-linked-list.md)。
-
-1. 解决这个问题，依然至少需要定义两个变量：`current`和`previous`。
-2. 循环条件应是`while (current.next != null)`，而不应该是`while (current != null)`，因为需要操作`current.next.next`.
-
-### 步骤
-1. 遍历所有节点。
-```java
-var previous = null;
-var current = head;
-
-while (current != null) {
-    current = current.next;
-}
-```
-
-2. 因为每两个节点进行一次位置互换，所以需要改为一次走两步。
-```java
-var previous = null;
-var current = head;
-
-while (current != null && current.next != null) { // 1
-    var nextNext = current.next.next; // 2
-    current = nextNext; // 3
-}
-```
-
-3. 交换 `current` 和 `current.next` 的位置。
-```java
-var previous = null;
-var current = head;
-
-while (current != null && current.next != null) {
-    var nextNext = current.next.next;
-
-    current.next.next = current; // 1
-    current.next = nextNext; // 2
-
-    current = nextNext;
-}
-```
-
-4. 处理 `previous`。
-```java
-var previous = null;
-var current = head;
-
-while (current != null && current.next != null) {
-    var nextNext = current.next.next;
-
-    previous.next = current.next; // 1
-    current.next.next = current;
-    current.next = nextNext;
-
-    previous = current; // 2
-    current = nextNext;
-}
-```
-
-5. 确定返回值。因为`head`节点在节点数量超过1时，会被交换到第二个节点的位置，为了统一方便处理，最好加入`dummy_head`节点。
-```java
-var dummyHead = new ListNode(); // 1
-dummyHead.next = head; // 2
-
-var previous = dummyHead; // 3
-var current = head;
-
-while (current != null && current.next != null) {
-    var nextNext = current.next.next;
-
-    previous.next = current.next;
-    current.next.next = current;
-    current.next = nextNext;
-
-    previous = current;
-    current = nextNext;
-}
-
-return dummyHead.next; // 4
-```
