LeetCode 25 K 个一组翻转链表

参加了 kkb 的门徒培训，想要记录下自己的成长过程。每天一篇，坚持不断更 --- 2022.3.7

题目描述

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

进阶：

• 你可以设计一个只使用常数额外空间的算法来解决此问题吗？
• 你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

 

示例 1：

输入： head = [1,2,3,4,5], k = 2
输出： [2,1,4,3,5]

示例 2：

输入： head = [1,2,3,4,5], k = 3
输出： [3,2,1,4,5]

示例 3：

输入： head = [1,2,3,4,5], k = 1
输出： [1,2,3,4,5]

示例 4：

输入： head = [1], k = 1
输出： [1]

提示：

• 列表中节点的数量在范围 sz 内
• 1 <= sz <= 5000
• 0 <= Node.val <= 1000
• 1 <= k <= sz

解题思路

翻转链表已经做了许多

1. LeetCode 206 反转链表
2. LeetCode 92 反转链表 II

类似的思路，修改一下下

/**
 * @param {ListNode} head
 * @param {number} k
 * @return {ListNode}
 */
var reverseKGroup = function(head, k) {
    // 判断是否为空
    if (!head) return null

    // 定义虚拟头
    let hair = new ListNode(-1, head);
    // 定义双指针便于交换
    let p = hair, q = p.next;

    // 正常的遍历，判空
    // while (1) {
    //     p.next = reverseN(p.next, k);
    //     for (let i = 0; i < k && p; i++) {
    //         p = p.next
    //     }
    //     if (!p) break
    // }

    // 一个小技巧，但是需要注意优先级
    while ((p.next = reverseN(q, k)) !== q) {
      p = q;
      q = q.next;
    }
    return hair.next;
};

// 判断是否在范围内
var reverseN = (head, l) => {
    let p = head;
    let n = l;

    while(--n && p) {
        p = p.next
    }

    if (p == null) return head
    
    return _reverseN_(head, l)
}

// 真正的翻转函数（递归）
// var _reverseN_ = (head, l) => {
//     if (l === 1) return head;

//     let tail = head.next;
//     let ret = _reverseN_(head.next, l - 1);
//     head.next = tail.next;
//     tail.next = head;
//     return ret;
// }

// 遍历实现
var _reverseN_ = (head, n) => {
    let pre = null, cur = head;
    while (n--) {
        // 数组解构时会缓存当前的变量
        [cur.next, pre, cur] = [pre, cur, cur.next];
    }
    head.next = cur;
    return pre;
};