[Leetcode] 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.

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

思路一：比较简单的方法是用一个stack去存。

class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        ListNode dummy(0);
        dummy.next = head;
        ListNode* group_runner = &dummy;
        ListNode* runner = head;
        bool end = false;
        stack<ListNode*> s;   //stack is a great option for reverse link list
        while (!end) {
            for (int i = 0; i < k; ++i) {
                if (runner == nullptr) {
                    end = true;
                    break;
                }
                s.push(runner);
                runner = runner->next;
            }
            if (!end) {
                while (!s.empty()) {
                    group_runner->next = s.top();
                    group_runner = group_runner->next;
                    s.pop();
                }
                group_runner->next = runner;
            }
        }
        return dummy.next;
    }
};

总结：复杂度为O(n)，但空间复杂度为O(n).

思路二：in-place. 定义一个新的函数可以reverse k个节点，在主函数中判断是否还有多余k个节点，如果有，则调用reverse函数。做法并不难，需要细心和耐心。

class Solution {
public:
    ListNode* reverse_k(ListNode* prev_end, int k) {   //reverse k nodes after prev_end
        ListNode* runner = prev_end->next;
        ListNode* new_end = prev_end->next;
        for (int i = 0; i < k; ++i) {
            ListNode* next_runner = runner->next;
            runner->next = prev_end->next;
            prev_end->next = runner;
            new_end->next = next_runner;
            runner = next_runner;
        }
        return new_end;
    }
    
    ListNode *reverseKGroup(ListNode *head, int k) {
        if (k <= 1) return head;
        ListNode dummy(0);
        dummy.next = head;
        ListNode* previous = &dummy;
        ListNode* runner = previous;
        while (runner != nullptr) {
            for (int i = 0; i < k; ++i) {   //find next k nodes
                if (runner == nullptr) break;   //less than k nodes, break
                runner = runner->next;
            }
            if (runner != nullptr) {   //larger than k nodes left, can reverse
                ListNode* next_head = runner->next;   //the head of the rest nodes (after k nodes)
                runner = reverse_k(previous, k);   //runner now is the end of the reversed k nodes
                runner->next = next_head;   //concatenate the reversed nodes with following nodes
                previous = runner;   //the end of the previous nodes
            }
        }
        return dummy.next;
    }
};

总结：复杂度为O(n)，空间复杂度为O(1).