25. K 个一组翻转链表

25. K 个一组翻转链表

题目描述

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

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

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

示例：

给你这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明：

• 你的算法只能使用常数的额外空间。
• 你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

---

题解：

链表上的模拟。

• 增加虚拟头节点 dummy ，这里没必要使用 new 一个新空间，可以这样操作：

  1. ListNode dummy, *tail = &dummy;
  2. tail->next = head;

• 令 cur 指向当前轮开始的前一个节点，开始时 cur = tail:

  1. first = cur, second = cur->next;
  2. 通过 first 指针遍历 k 个节点停止，不足 k 个则退出循环
  3. 原地翻转 second 和 first 之间的节点

• 更新节点的指向：

  1. second->next = first->next;
  2. cur->next = first;
  3. cur = second;

这个循环直到 first 为空时停止。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if ( !head || k == 1 ) return head;
        ListNode dummy, *tail = &dummy;
        tail->next = head;
        ListNode *first = nullptr, *second = nullptr, *cur = tail;
        ListNode *p1 = nullptr, *p2 = nullptr, *ans = nullptr;
        int num = 0;
        while ( true ) {
            first = cur;
            second = cur->next;
            for( num = 0; num < k && first; ++num )
                first = first->next;
            if ( !first ) break;

            p1 = second;
            p2 = second->next;
            while ( p1 != first ) {
                ans = p2->next;
                p2->next = p1;
                p1 = p2;
                p2 = ans;
            }

            second->next = p2;
            cur->next = first;
            cur = second;
        }
        return dummy.next;
    }
};
/*
时间：12ms，击败：99.86%
内存：11.3MB，击败：96.19%
*/