[leetcode 25]. K 个一组翻转链表

题目描述：

https://leetcode.cn/problems/reverse-nodes-in-k-group

给你链表的头节点 head ，每 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]

提示：

• 链表中的节点数目为 n
• 1 <= k <= n <= 5000
• 0 <= Node.val <= 1000

进阶：你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？

解题思路：

和92题反转过程类似，⚠️要创建临时变量nxt保存p0.next,最后更新p0=nxt，开启下一轮循环

代码（C++&Python）:

class Solution:
    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:

        # 统计链表个数
        n=0
        cur=head
        while cur:
            n+=1
            cur=cur.next
        
        dummy=ListNode(next=head)
        p0=dummy

        # 每次反转前看剩余节点个数是否>=k,>=k则反转，否则不反转
        while n>=k:
            n-=k
            cur=p0.next
            pre=None
            for _ in range(k):
                nxt=cur.next
                cur.next=pre
                pre=cur
                cur=nxt
            
            # 保存下一轮循环的上一个节点为p0
            next=p0.next
            p0.next.next=cur
            p0.next=pre
            p0=next
        
        return dummy.next

/**
 * 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) {
        int n=0;
        ListNode* cur=head;
        while(cur){
            n++;
            cur=cur->next;
        }

        ListNode dummy(0,head);
        ListNode* p0=&dummy;
        ListNode* nxt=nullptr;
        ListNode* pre=nullptr;
        cur=p0->next;

        while(n>=k){
            n-=k;
            for(int i=0;i<k;i++){
                nxt=cur->next;
                cur->next=pre;
                pre=cur;
                cur=nxt;
            }

            ListNode* next=p0->next;
            p0->next->next=cur;
            p0->next=pre;
            p0=next;
        }

        return dummy.next;    
    }
};

思路总结：

做题顺序：

206. 反转链表

24. 两两交换链表中的节点