update 20 24 25 92 133 224

Author: 2xiao

assets/output/0092.md

@@ -80,6 +80,24 @@ var isValid = function (s) {
 	}
 	return stack.length === 0;
 };
+
+// 简化写法
+var isValid = function (s) {
+	let stack = [],
+		obj = {
+			')': '(',
+			']': '[',
+			'}': '{'
+		};
+	for (let item of s) {
+		if ('[{('.indexOf(item) != -1) {
+			stack.push(item);
+		} else if (obj[item] != stack.pop()) {
+			return false;
+		}
+	}
+	return stack.length == 0;
+};
 ```
 
 ## 相关题目

assets/output/0138.md

@@ -34,24 +34,43 @@ only nodes themselves may be changed.)
 
 ## 题目大意
 
-两两相邻的元素，翻转链表
+给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
 
 ## 解题思路
 
-按照题意做即可。
+### 思路一：迭代法
+
+1. 使用一个虚拟头节点 `res` 作为新链表的头，避免处理头节点时的边界问题；
+2. 初始化 `prev` 指针指向虚拟头节点；
+3. 使用 `prev` 指针来遍历链表，每次交换相邻的节点 `prev.next` 和 `prev.next.next`，并更新 `prev` 指针，使其指向交换后的第二个节点；
+4. 遍历的终止条件是：`prev.next` 或 `prev.next.next` 不存在了，即剩余节点不足两个；
+5. 返回结果；
+
+### 思路二：递归法
+
+1. 递归终止条件：如果链表为空或只有一个节点，则返回原链表，因为没有节点可交换；
+2. 交换节点：交换当前节点对，并将交换后的链表头设置为 second，递归处理剩下的链表 rest；
+3. 返回新头节点：返回新的链表头 second；
 
 ## 代码
 
+:::: code-tabs
+
+@tab 迭代法
+
 ```javascript
 /**
  * @param {ListNode} head
  * @return {ListNode}
  */
 var swapPairs = function (head) {
+	// 构造虚拟头节点
 	let res = new ListNode(0, head);
 	let prev = res;
 
+	// 遍历链表
 	while (prev.next && prev.next.next) {
+		// 交换前两个节点
 		let cur = prev.next;
 		let temp = cur.next;
 		cur.next = temp.next;
@@ -63,6 +82,35 @@ var swapPairs = function (head) {
 };
 ```
 
+@tab 递归法
+
+```javascript
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var swapPairs = function (head) {
+	// 如果链表为空或只有一个节点，不需要交换
+	if (!head || !head.next) {
+		return head;
+	}
+
+	// 交换前两个节点
+	let first = head;
+	let second = head.next;
+	let rest = second.next;
+
+	// 递归处理剩下的链表
+	second.next = first;
+	first.next = swapPairs(rest);
+
+	// 返回新头节点
+	return second;
+};
+```
+
+::::
+
 ## 相关题目
 
 :::: md-demo 相关题目

src/leetcode/problem/0020.md

@@ -40,14 +40,111 @@ changed.
 
 ## 题目大意
 
-按照每 K 个元素翻转的方式翻转链表。如果不满足 K 个元素的就不翻转。
+给你链表的头节点 `head` ，每 `k` 个节点一组进行翻转，请你返回修改后的链表。
+
+`k` 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 `k` 的整数倍，那么请将最后剩余的节点保持原有顺序。
+
+你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
 
 ## 解题思路
 
-这一题是 [第 24 题](./0024.md) 的加强版，第 24 题是两两相邻的元素，翻转链表。而本题要求的是 k 个相邻的元素，翻转链表，第 24 题相当于是 k = 2 的特殊情况。
+这一题是 [第 24 题](./0024.md) 的加强版，第 24 题是两两相邻的元素，翻转链表。而本题要求的是 `k` 个相邻的元素，翻转链表，第 24 题相当于是 `k = 2` 的特殊情况。
+
+### 思路一：迭代法
+
+1. 使用 `dummy` 作为虚拟头节点，方便处理链表的连接和首节点的反转；
+2. 首先遍历链表，获取链表长度 `length`，用于判断是否有足够的 `k` 个节点进行反转；
+3. 每次找到 `k` 个节点进行反转，通过循环来交换节点的位置，并保持链表正确的连接顺序；
+4. 反转完成后，将指针 `prev` 移动到下一组的前一个节点，继续遍历下一组 `k` 个节点，直到剩余节点不足 `k`；
+
+- 时间复杂度为 `O(n)`
+- 空间复杂度为 `O(1)`
+
+### 思路二：递归法
+
+1. **判断是否足够 `k` 个节点**：在每次递归之前，遍历前 `k` 个节点，判断是否有足够的 `k` 个节点。如果不足 `k` 个，则直接返回当前链表，不进行反转。
+2. **反转前 `k` 个节点**：通过循环逐个反转 `k` 个节点。使用 `prev` 来记录已经反转的部分，`curr` 用来遍历当前节点，`next` 记录下一个节点的位置。
+3. **递归处理剩余部分**：在反转 `k` 个节点后，递归处理剩余的链表部分，并将递归结果连接到反转后的链表。
+4. **返回结果**：每次递归都返回反转后的链表头节点。
+
+- 时间复杂度为 `O(n)`
+- 递归方式更加直观，反转过程简洁，但递归栈的深度为 `O(n/k)`，因此空间复杂度为 `O(n/k)`
 
 ## 代码
 
+:::: code-tabs
+@tab 迭代法
+
+```javascript
+var reverseKGroup = function (head, k) {
+	// 创建虚拟头节点，方便处理链表连接
+	let dummy = new ListNode(0);
+	dummy.next = head;
+	let prev = dummy;
+
+	// 统计链表长度
+	let length = 0;
+	let temp = head;
+	while (temp) {
+		length++;
+		temp = temp.next;
+	}
+
+	// 逐步反转每组k个节点
+	while (length >= k) {
+		let curr = prev.next;
+		let next = curr.next;
+		for (let i = 1; i < k; i++) {
+			curr.next = next.next;
+			next.next = prev.next;
+			prev.next = next;
+			next = curr.next;
+		}
+		// 移动指针到下一组
+		prev = curr;
+		length -= k;
+	}
+
+	return dummy.next;
+};
+```
+
+@tab 递归法
+
+```javascript
+var reverseKGroup = function (head, k) {
+	// 判断剩余节点是否足够k个，不够则返回原链表
+	let count = 0;
+	let node = head;
+	while (count < k && node) {
+		node = node.next;
+		count++;
+	}
+	if (count < k) {
+		return head;
+	}
+
+	// 反转前k个节点
+	let prev = null;
+	let curr = head;
+	let next = null;
+	for (let i = 0; i < k; i++) {
+		next = curr.next;
+		curr.next = prev;
+		prev = curr;
+		curr = next;
+	}
+
+	// 递归处理剩下的链表，并连接到反转后的链表
+	head.next = reverseKGroup(curr, k);
+
+	// 返回反转后的头节点
+	return prev;
+};
+```
+
+@tab 递归法二
+
 ```javascript
 /**
  * @param {ListNode} head
@@ -89,6 +186,8 @@ var reverse = function (first, last) {
 };
 ```
 
+::::
+
 ## 相关题目
 
 :::: md-demo 相关题目