链表中节点每k个一组翻转

#include <iostream>
using namespace std;

// 链表节点结构体
struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(NULL) {}
};

ListNode* reverseKGroup(ListNode* head, int k) {
    if (head == NULL || k == 1) {
        return head;
    }
    //创建虚拟头节点dummy指向链表的头节点
    ListNode* dummy = new ListNode(-1);
    dummy->next = head;
    //创建pre和curr指针分别指向需要逆置的区间的前一个节点和第一个节点
    ListNode* pre = dummy;
    ListNode* curr = head;
    //计数器i，用于记录当前遍历到的节点位置
    int i = 0;

    while (curr != NULL) {
        //每遍历一个节点计数器加1
        i++;//
        if (i % k == 0) //余数为0，说明当前遍历到的节点是需要逆置的区间的最后一个节点
        {
            //调用reverseList函数对该区间内节点进行逆置操作，使pre指向逆置后区间的最后一个节点
            pre = reverseList(pre, curr->next);
            //curr指针指向下一个需要逆置区间的第一个节点
            curr = pre->next;
        }
        else {
            //节点数不是 k 的倍数，将最后剩下的节点保持原样
            curr = curr->next;
        }
    }

    return dummy->next;
}

ListNode* reverseList(ListNode* pre, ListNode* next) {
    //last和curr需要逆置区间的第一个节点和第二个节点
    ListNode* last = pre->next;
    ListNode* curr = last->next;

    while (curr != next) {
        last->next = curr->next;
        curr->next = pre->next;
        pre->next = curr;
        curr = last->next;
    }

    return last;
}

// 测试代码
int main() {
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(4);
    head->next->next->next->next = new ListNode(5);

    ListNode* newHead = reverseKGroup(head, 3);

    while (newHead != NULL) {
        cout << newHead->val << " ";
        newHead = newHead->next;
    }

    return 0;
}