LeetCode-Reverse Nodes in k-Group

繁琐的链表操作，很开心，一次就过了，不过推敲的时间也有20分钟了，

还是加快思考的速度。

/**
 * 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) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (head == NULL || k <= 1) {
            return head;
        }       
        ListNode *first = getKNode(head, k);
        if (first == head) {
            return head;
        }
        ListNode *res = first;
        ListNode *start = first->next;
        reverse(head, first);
        ListNode *pre = head;
        while (start) {
            first = getKNode(start, k);
            if (first == start) {
                pre->next = start;
                return res;
            }
            pre->next = first;
            pre = start;
            ListNode *temp = first->next;
            reverse(start, first);
            start = temp;
        }
        if (start == NULL) {
            pre->next = NULL;
            return res;
        }
        return res;
    }
    ListNode *getKNode(ListNode *head, int k) {
        ListNode *first = head;
        int count = 1;
        while (first->next && count < k) {
            first = first->next;
            ++count;
        }
        if (first->next == NULL && count < k) {
            return head;
        }
        return first;
    } 
    void reverse(ListNode *start, ListNode *end) {
        ListNode *pre = start;
        ListNode *iter = start->next;
        while (iter != end) {
            ListNode *temp = iter->next;
            iter->next = pre;
            pre = iter;
            iter = temp;
        }
        end->next = pre;
    }
};