feat: 链表专题

Author: lucifer

problems/206.reverse-linked-list.md

@@ -1,7 +1,9 @@
 ## 题目地址
+
 https://leetcode.com/problems/reverse-linked-list/description/
 
 ## 题目描述
+
 Reverse a singly linked list.
 
 Example:
@@ -15,11 +17,13 @@ A linked list can be reversed either iteratively or recursively. Could you imple
 ## 前置知识
 
 - 链表
-  
+
 ## 思路
+
 这个就是常规操作了，使用一个变量记录前驱 pre，一个变量记录后继 next.
 
 不断更新`current.next = pre` 就好了
+
 ## 关键点解析
 
 - 链表的基本操作（交换）
@@ -44,22 +48,21 @@ JavaScript Code：
  * @param {ListNode} head
  * @return {ListNode}
  */
-var reverseList = function(head) {
-    if (!head || !head.next) return head;
+var reverseList = function (head) {
+  if (!head || !head.next) return head;
 
-    let cur = head;
-    let pre = null;
+  let cur = head;
+  let pre = null;
 
-    while(cur) {
-        const next = cur.next;
-        cur.next = pre;
-        pre = cur;
-        cur = next;
-    }
+  while (cur) {
+    const next = cur.next;
+    cur.next = pre;
+    pre = cur;
+    cur = next;
+  }
 
-    return pre;
+  return pre;
 };
-
 ```
 
 C++ Code：
@@ -139,6 +142,7 @@ class Solution {
 ## 拓展
 
 通过单链表的定义可以得知，单链表也是递归结构，因此，也可以使用递归的方式来进行 reverse 操作。
+
 > 由于单链表是线性的，使用递归方式将导致栈的使用也是线性的，当链表长度达到一定程度时，递归会导致爆栈，因此，现实中并不推荐使用递归方式来操作链表。
 
 ### 描述
@@ -148,7 +152,8 @@ class Solution {
 
 > 这里需要注意的是，每次需要保存已经 reverse 的链表的头节点和尾节点
 
-###  C++实现
+### C++实现
+
 ```c++
 // 普通递归
 class Solution {
@@ -197,27 +202,29 @@ public:
 ```
 
 ### JavaScript 实现
+
 ```javascript
-var reverseList = function(head) {
+var reverseList = function (head) {
   // 递归结束条件
   if (head === null || head.next === null) {
-    return head
+    return head;
   }
 
   // 递归反转 子链表
-  let newReverseList = reverseList(head.next)
+  let newReverseList = reverseList(head.next);
   // 获取原来链表的第 2 个节点 newReverseListTail
-  let newReverseListTail = head.next
+  let newReverseListTail = head.next;
   // 调整原来头结点和第 2 个节点的指向
-  newReverseListTail.next = head
-  head.next = null
+  newReverseListTail.next = head;
+  head.next = null;
 
   // 将调整后的链表返回
-  return newReverseList
-}
+  return newReverseList;
+};
 ```
 
 ### Python 实现
+
 ```python
 class Solution:
     def reverseList(self, head: ListNode) -> ListNode:
@@ -227,3 +234,8 @@ class Solution:
         head.next = None
         return ans
 ```
+
+## 相关题目
+
+- [92.reverse-linked-list-ii](./92.reverse-linked-list-ii.md)
+- [25.reverse-nodes-in-k-groups](./25.reverse-nodes-in-k-groups-cn.md)

problems/25.reverse-nodes-in-k-groups-cn.md

@@ -1,7 +1,9 @@
 ## 题目地址
+
 https://leetcode.com/problems/reverse-nodes-in-k-group/
 
 ## 题目描述
+
 ```
 Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.
 
@@ -27,12 +29,14 @@ You may not alter the values in the list's nodes, only nodes itself may be chang
 - 链表
 
 ## 思路
-题意是以 `k` 个nodes为一组进行翻转，返回翻转后的`linked list`.
 
-从左往右扫描一遍`linked list`，扫描过程中，以k为单位把数组分成若干段，对每一段进行翻转。给定首尾nodes，如何对链表进行翻转。
+题意是以 `k` 个 nodes 为一组进行翻转，返回翻转后的`linked list`.
+
+从左往右扫描一遍`linked list`，扫描过程中，以 k 为单位把数组分成若干段，对每一段进行翻转。给定首尾 nodes，如何对链表进行翻转。
+
+链表的翻转过程，初始化一个为`null`的 `previous node（prev）`，然后遍历链表的同时，当前`node （curr）`的下一个（next）指向前一个`node（prev）`，
+在改变当前 node 的指向之前，用一个临时变量记录当前 node 的下一个`node（curr.next)`. 即
 
-链表的翻转过程，初始化一个为`null `的 `previous node（prev）`，然后遍历链表的同时，当前`node （curr）`的下一个（next）指向前一个`node（prev）`，
-在改变当前node的指向之前，用一个临时变量记录当前node的下一个`node（curr.next)`. 即
 ```
 ListNode temp = curr.next;
 curr.next = prev;
@@ -50,40 +54,41 @@ curr = temp;
 
 2. 用一个`start` 变量记录当前分组的起始节点位置的前一个节点
 
-3. 用一个`end `变量记录要翻转的最后一个节点位置
+3. 用一个`end`变量记录要翻转的最后一个节点位置
 
 4. 翻转一组（`k个nodes`）即`(start, end) - start and end exclusively`。
 
 5. 翻转后，`start`指向翻转后链表, 区间`（start，end）`中的最后一个节点, 返回`start` 节点。
 
 6. 如果不需要翻转，`end` 就往后移动一个（`end=end.next`)，每一次移动，都要`count+1`.
 
-如图所示 步骤4和5： 翻转区间链表区间`（start， end）`
+如图所示 步骤 4 和 5： 翻转区间链表区间`（start， end）`
 
 ![reverse linked list range in (start, end)](../assets/problems/25.reverse-nodes-in-k-groups-3.png)
 
-
 举例如图，`head=[1,2,3,4,5,6,7,8], k = 3`
 
-
 ![reverse k nodes in linked list](../assets/problems/25.reverse-nodes-in-k-groups-2.PNG)
 
-
->**NOTE**: 一般情况下对链表的操作，都有可能会引入一个新的`dummy node`，因为`head`有可能会改变。这里`head 从1->3`,
-`dummy (List(0)) `保持不变。
+> **NOTE**: 一般情况下对链表的操作，都有可能会引入一个新的`dummy node`，因为`head`有可能会改变。这里`head 从1->3`,
+> `dummy (List(0))`保持不变。
 
 #### 复杂度分析
-- *时间复杂度:* `O(n) - n is number of Linked List`
-- *空间复杂度:* `O(1)`
+
+- _时间复杂度:_ `O(n) - n is number of Linked List`
+- _空间复杂度:_ `O(1)`
 
 ## 关键点分析
-1. 创建一个dummy node
-2. 对链表以k为单位进行分组，记录每一组的起始和最后节点位置
+
+1. 创建一个 dummy node
+2. 对链表以 k 为单位进行分组，记录每一组的起始和最后节点位置
 3. 对每一组进行翻转，更换起始和最后的位置
 4. 返回`dummy.next`.
 
 ## 代码 (`Java/Python3/javascript`)
-*Java Code*
+
+_Java Code_
+
 ```java
 class ReverseKGroupsLinkedList {
   public ListNode reverseKGroup(ListNode head, int k) {
@@ -142,7 +147,8 @@ class ReverseKGroupsLinkedList {
 }
 ```
 
-*Python3 Cose*
+_Python3 Cose_
+
 ```python
 class Solution:
     def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
@@ -181,79 +187,131 @@ class Solution:
 
 ```
 
-*javascript code*
+_javascript code_
+
 ```js
 /**
  * @param {ListNode} head
  * @param {number} k
  * @return {ListNode}
  */
-var reverseKGroup = function(head, k) {
+var reverseKGroup = function (head, k) {
   // 标兵
-  let dummy = new ListNode()
-  dummy.next = head
-  let [start, end] = [dummy, dummy.next]
-  let count = 0
-  while(end) {
-    count++
+  let dummy = new ListNode();
+  dummy.next = head;
+  let [start, end] = [dummy, dummy.next];
+  let count = 0;
+  while (end) {
+    count++;
     if (count % k === 0) {
-      start = reverseList(start, end.next)
-      end = start.next
+      start = reverseList(start, end.next);
+      end = start.next;
     } else {
-      end = end.next
+      end = end.next;
     }
   }
-  return dummy.next
+  return dummy.next;
 
   // 翻转stat -> end的链表
   function reverseList(start, end) {
-    let [pre, cur] = [start, start.next]
-    const first = cur
-    while(cur !== end) {
-      let next = cur.next
-      cur.next = pre
-      pre = cur
-      cur = next
+    let [pre, cur] = [start, start.next];
+    const first = cur;
+    while (cur !== end) {
+      let next = cur.next;
+      cur.next = pre;
+      pre = cur;
+      cur = next;
     }
-    start.next = pre
-    first.next = cur
-    return first
+    start.next = pre;
+    first.next = cur;
+    return first;
   }
 };
-
 ```
 
 ## 参考（References)
+
 - [Leetcode Discussion (yellowstone)](https://leetcode.com/problems/reverse-nodes-in-k-group/discuss/11440/Non-recursive-Java-solution-and-idea)
 
-## 扩展
+## 扩展 1
 
 - 要求从后往前以`k`个为一组进行翻转。**(字节跳动（ByteDance）面试题)**
 
-    例子，`1->2->3->4->5->6->7->8, k = 3`,
+  例子，`1->2->3->4->5->6->7->8, k = 3`,
+
+  从后往前以`k=3`为一组，
 
-    从后往前以`k=3`为一组，
-    - `6->7->8` 为一组翻转为`8->7->6`，
-    - `3->4->5`为一组翻转为`5->4->3`.
-    - `1->2`只有2个nodes少于`k=3`个，不翻转。
+  - `6->7->8` 为一组翻转为`8->7->6`，
+  - `3->4->5`为一组翻转为`5->4->3`.
+  - `1->2`只有 2 个 nodes 少于`k=3`个，不翻转。
 
-    最后返回： `1->2->5->4->3->8->7->6`
+  最后返回： `1->2->5->4->3->8->7->6`
 
 这里的思路跟从前往后以`k`个为一组进行翻转类似，可以进行预处理：
 
 1. 翻转链表
 
-2. 对翻转后的链表进行从前往后以k为一组翻转。
+2. 对翻转后的链表进行从前往后以 k 为一组翻转。
 
-3. 翻转步骤2中得到的链表。
+3. 翻转步骤 2 中得到的链表。
 
 例子：`1->2->3->4->5->6->7->8, k = 3`
 
 1. 翻转链表得到：`8->7->6->5->4->3->2->1`
 
-2. 以k为一组翻转： `6->7->8->3->4->5->2->1`
+2. 以 k 为一组翻转： `6->7->8->3->4->5->2->1`
+
+3. 翻转步骤#2 链表： `1->2->5->4->3->8->7->6`
+
+## 扩展 2
+
+如果这道题你按照 [92.reverse-linked-list-ii](./92.reverse-linked-list-ii.md) 提到的 `p1, p2, p3, p4`（四点法） 的思路来思考的话会很清晰。
+
+代码如下（Python）：
+
+```py
+
+class Solution:
+    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
+        if head is None or k < 2:
+            return head
+        dummy = ListNode(0)
+        dummy.next = head
+        pre = dummy
+        cur = head
+        count = 0
+        while cur:
+            count += 1
+            if count % k == 0:
+                pre = self.reverse(pre, cur.next)
+                # end 调到下一个位置
+                cur = pre.next
+            else:
+                cur = cur.next
+        return dummy.next
+    # (p1, p4） 左右都开放
+
+    def reverse(self, p1, p4):
+        prev, curr = p1, p1.next
+        p2 = curr
+        # 反转
+        while curr != p4:
+            next = curr.next
+            curr.next = prev
+            prev = curr
+            curr = next
+        # 将反转后的链表添加到原链表中
+        # prev 相当于 p3
+        p1.next = prev
+        p2.next = p4
+        # 返回反转前的头， 也就是反转后的尾部
+        return p2
+
+# @lc code=end
+
+```
 
-3. 翻转步骤#2链表： `1->2->5->4->3->8->7->6`
+## 相关题目
 
-## 类似题目
-- [Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs/)
+- [92.reverse-linked-list-ii](./92.reverse-linked-list-ii.md)
+- [206.reverse-linked-list](./206.reverse-linked-list.md)