1.给定一个单链表的头结点head, 实现一个调整单链表的函数，使得k个结点之间逆序，如果最后一组不够k个节点，则不调整最后几个结点。要求：如果链表的长度为N；时间复杂度达到O(N)。

可以使用迭代的方式来实现这个功能。具体步骤如下：

1. 定义一个指针pre，指向当前需要逆序的k个结点的前一个结点，初始值为head。
2. 定义一个指针end，指向当前需要逆序的k个结点的最后一个结点，初始值为head。
3. 定义一个指针next，指向当前需要逆序的k个结点的下一个结点，初始值为head.next。
4. 定义一个计数器count，用于记录当前已经逆序的结点个数，初始值为1。
5. 从第k个结点开始，依次将当前结点插入到pre和pre.next之间，直到插入到end为止。
6. 将pre指向end，将end指向next，将next指向下一个需要逆序的k个结点的第一个结点。
7. 重复步骤5和6，直到链表末尾。

代码如下：

public 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 end = dummy;
    while (end.next != null) {
        for (int i = 0; i < k && end != null; i++) {
            end = end.next;
        }
        if (end == null) {
            break;
        }
        ListNode next = end.next;
        ListNode start = pre.next;
        end.next = null;
        pre.next = reverse(start);
        start.next = next;
        pre = start;
        end = start;
    }
    return dummy.next;
}

private ListNode reverse(ListNode head) {
    ListNode pre = null;
    ListNode cur = head;
    while (cur != null) {
        ListNode next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
    }
    return pre;
}

其中，reverse函数用于将一个链表逆序。时间复杂度为O(N)，空间复杂度为O(1)。