Reverse Nodes in k-Group

一. Reverse Nodes in k-Group

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.

Only constant memory is allowed.

For example,

Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5

Difficulty:Hard

TIME：35MIN

解法一（递归）

很多链表问题都可以采用递归来求解，这道题也不例外。每次递归的过程中，都对链表的前k个结点进行反转，如果小于k个结点，就不反转链表。

ListNode* reverseKGroup(ListNode* head, int k) {
    if(k <= 1)
        return head;
    ListNode *p = head;
    int num = 0;
    while(p != NULL && num != k) {
        p = p->next;
        num++;
    }
    if(num == k) {
        p = reverseKGroup(p, k); //这里的p指向的是第k+1个结点
        while(num > 0) { //每次循环都将一个结点添加到p结点的前面
            ListNode *cur = head->next;
            head->next = p;
            p = head;
            head = cur;
            num--;
        }
        head = p; //这里的p指向的是第1个结点
    }
    return head;
}

代码的时间复杂度为$O(n)$。

解法二（迭代）

和递归方法类似，不过通过一些额外的变量保存了一些状态信息。

ListNode* reverseKGroup(ListNode* head, int k) {
    if(k <= 1 || head == NULL)
        return head;
    ListNode *p = head;
    ListNode *end = head;  //指向k个结点已经反转的尾结点（固定）
    ListNode *nex = end->next; //指向k个结点已经反转的尾节点的下一个结点
    ListNode *result = new ListNode(-1);
    result->next = head;
    ListNode *pre = result; //指向k个结点已经反转的首结点的前一个结点
    int num = 0;
    while(p != NULL) {
        p = p->next;
        num++;
    }
    while(num >= k) {
        end = pre->next;
        nex = end->next;
        for(int i = 1; i < k; i++) { //反转至少需要3个结点的参与
            end->next = nex->next;
            nex->next = pre->next;
            pre->next = nex;
            nex = end->next;
        }
        pre = end;
        num -= k;
    }
    return result->next; //result一定会指向链表的首元素的前一个结点
}

代码的时间复杂度为$O(n)$。