Reverse Nodes in k-Group -- leetcode

Given a linked list, reverse the nodes of a linked list k at a time and return its modified 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

算法基本思路为，链表倒排。

特点为，只扫描一次，仅一次。

节点个数如果不是k整倍数时，在处理最后一个片断时，采取二次倒排，以恢复原始顺序。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        if (k <= 1) return head;
        ListNode fake(0);
        ListNode *prev = &fake;
        ListNode *last = head;
        int i = k;
        short state = 0;

        while (state < 2) {
                if (head) {
                        if (!i) {
                                prev = last;
                                last = head;
                                i = k;
                        }
                        ListNode *bak = head->next;
                        head->next = prev->next;
                        prev->next = head;
                        head = bak;
                        --i;
                }
                else {
                        ++state;
                        if (!i)
                                ++state;
                        else if (state < 2) {
                                head = prev->next;
                                prev->next = 0;
                                i = k;
                        }
                }
        }

        return fake.next;
    }
};

此算法在leetcode上执行时间为120ms。

以下基于同样的思路第二种写法。

特点是将链表倒排独立成一个函数。

此写法在leetcode上的实际执行时间为108ms。

class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        if (k <= 1) return head;
        ListNode fake(0);
        fake.next = head;
        ListNode *prev;
        ListNode *last = &fake;
        int count = 0;

        while (!count) {
                count = k;
                prev = last;
                last = last->next;
                reverse(prev, count);
        }

        reverse(prev, k);
        return fake.next;
    }

    void reverse(ListNode *prev, int &k) {
        ListNode *p = prev->next;
        ListNode *last = p;
        while (p && k) {
                ListNode *bak = p->next;
                p->next = prev->next;
                prev->next = p;
                p = bak;
                last->next = p;
                --k;
        }
    }
};