题目：

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

思路：

链表反序本来不是什么难题，主要是要考虑多次循环、链表节点的有效性等。

代码：

/**
 * 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) {
        ListNode * newTail = new ListNode(0);
        ListNode * newPtr = newTail;
        
        ListNode * ptr = head;
        ListNode* next;
        
        while(ptr != NULL){
            next = ptr;
            int len = k;
            while(len > 0 && next != NULL){
                next = next->next;
                len--;
            }
            //判断是否还存在k个未处理的结点
            
            if(len == 0){
                while(ptr != next){
                    ListNode* tmp = ptr;
                    ptr = ptr->next;
                    tmp->next = newPtr->next;
                    newPtr->next = tmp;
                }
                //倒置结点
            }
            else{
                newPtr->next = ptr;
                break;
                //直接连接旧了链表
            }
            
            while(newPtr->next != NULL){
                newPtr = newPtr->next;
            }
            //移动新的链接指针
        }
        return newTail->next;
    }
};