C++程序：用于反转给定大小组中的链表（第2组）

这个C++程序用于反转给定大小组中的链表，这是一个常见的算法问题。该程序通过遍历链表，先将链表分段，再对每一组进行反转，并且将已反转的链表头与下一组的头进行连接。

以下是代码片段：

#include <iostream>
using namespace std;

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

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if (!head || !head->next || k == 1) return head;
        ListNode* dummy = new ListNode(0); // 添加哑结点
        dummy->next = head;
        ListNode* pre = dummy, * end = dummy;

        while (end->next) {
            for (int i = 0; i < k && end != nullptr; i++) end = end->next; // 从哑结点开始，找到每组的后一项
            if (!end) break; // end为NULL代表当前组不满足k个节点
            ListNode *start = pre->next, *next = end->next; // 反转前保存当前组的首尾节点
            end->next = nullptr; // 分组结束，尾节点下一项置为NULL，便于反转
            pre->next = reverse(start); // 反转当前组链表
            start->next = next; // 反转后将链表连接到下一组
            pre = start; // 当前组结束，更新pre为下一组的前一个节点
            end = pre; // end也更新为pre，进行下一组的分组
        }
        return dummy->next;
    }

    // 实现反转链表的功能
    ListNode* reverse(ListNode* head) {
        if (!head || !head->next) return head;
        ListNode* next = head->next;
        ListNode* new_head = reverse(next);
        next->next = head;
        head->next = nullptr;
        return new_head;
    }
};

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);
    int k = 2;
    Solution* s = new Solution();
    ListNode* new_head = s->reverseKGroup(head, k);

    while (new_head) {
        cout<< new_head->val <<endl;
        new_head = new_head->next;
    }
    return 0;
}

上述程序主要用到了链表反转算法。反转链表是比较基础的链表问题，它是许多其他问题的重要基础。我们可以用递归或迭代的方式来实现链表反转。在这个程序中，我们采用了递归的方法实现链表反转。对于每组节点，我们先从哑结点开始向下遍历，找到每组的后一项，然后进行反转，并将反转后的链表连接到下一组。每组反转之后，我们更新pre和end点，进行下一组的分组和反转，直到整个链表的反转结束。