1.给定一个单链表的头结点head，实现一个调整单链表的函数，使得k个结点之 间逆序，如果最后一组不够k个节点，则不调整最后几个结点。要求：如果链 表的长度为N；时间复杂度达到O(N)。 例如： 链表：1->2->3->4->5->6->7->8->nul;k=3。 调整后：3-≥2-≥1-5->5-≥4-≥7->8->nu1l。

可以使用迭代的方式来实现这个函数，具体步骤如下：

1. 定义一个指针pre，指向当前需要逆序的k个结点的前一个结点，初始值为head。
2. 定义一个指针cur，指向当前需要逆序的k个结点的第一个结点，初始值为head->next。
3. 定义一个指针next，指向cur的下一个结点，用于保存下一个需要逆序的k个结点的第一个结点。
4. 定义一个指针tail，指向当前需要逆序的k个结点的最后一个结点，初始值为cur。
5. 定义一个计数器count，用于记录当前已经逆序的结点个数，初始值为1。
6. 进入循环，循环条件为cur不为NULL：
1. 如果count等于k，说明当前需要逆序的k个结点已经处理完毕，将pre的下一个结点指向tail，将cur的下一个结点指向next，更新pre为tail，更新cur为next，将count重置为1。
2. 否则，将cur的下一个结点指向pre，更新tail为cur，更新cur为next，更新next为next的下一个结点，将count加1。
7. 返回head。

完整代码如下：

ListNode* reverseKGroup(ListNode* head, int k) {
    if (head == NULL || k == 1) {
        return head;
    }
    ListNode* dummy = new ListNode(0);
    dummy->next = head;
    ListNode* pre = dummy;
    ListNode* cur = head;
    int count = 1;
    while (cur != NULL) {
        ListNode* next = cur->next;
        if (count == k) {
            ListNode* tail = pre->next;
            while (count > 1) {
                ListNode* tmp = tail->next;
                tail->next = cur->next;
                cur->next = tail;
                tail = tmp;
                count--;
            }
            pre->next = cur;
            pre = tail;
            cur = next;
            count = 1;
        } else {
            cur->next = pre->next;
            pre->next = cur;
            cur = next;
            count++;
        }
    }
    return dummy->next;
}