【Leetcode】【Hard】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

解题：

先写一个函数，输入为待反转的子链表首结点和k，功能是反转子链表前K个结点，剩余结点不变；如果不够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 (head == NULL || head->next == NULL || k == )
             return head;
         ListNode* newhead = new ListNode();
         ListNode* newlist = newhead;
         ListNode* curNode = head;
         while (curNode != NULL) {
             newlist->next = reverseListKNodes(curNode, k);
             // After "reverseListKNodes" func, "curNode" will be the end of reversed sublist
             newlist = curNode;
             curNode = curNode->next;
         }

         head = newhead->next;
         delete newhead;
         return head;
     }

     ListNode* reverseListKNodes(ListNode* sub_head, int k) {
         if (sub_head == NULL || sub_head->next == NULL)
             return sub_head;

         ListNode* newhead = NULL;
         ListNode* nodesleft = sub_head;
         ListNode* curNode = NULL;

         for (int i = ; i < k; ++i) {
             if (nodesleft == NULL)
                 return reverseListKNodes(newhead, i);
             curNode = nodesleft;
             nodesleft = nodesleft->next;
             curNode->next = newhead;
             newhead = curNode;
         }

         sub_head->next = nodesleft;
         return newhead;
     }
 };