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

跟链表的成对转换有异曲同工之意。这里主要考虑的有两点：

1）链表逻辑转换的调用和操作

2）不要存在悬浮指针和断开链接

/**

 * Definition for singly-linked list.

 * struct ListNode {

 *     int val;

 *     ListNode *next;

 *     ListNode(int x) : val(x), next(NULL) {}

 * };

 */

class Solution {

public:

    void reverse(ListNode * first,ListNode * end)//把k个元素置逆

    {

         ListNode * p1 = first;

        ListNode * p2;

		while(p1 != end&&p1!=NULL)//避免出现悬浮指针，也就是不要对空指针操作

        {

            p2 = p1->next;

            p1->next = end->next;

            end->next = p1;

	    p1 = p2;

        }//最后first指针在最后了，指向了兴许链表

    }

    ListNode *reverseKGroup(ListNode *head, int k) {

       if(head == NULL || k<2)

       return head;

       ListNode * first = head;

       ListNode * end = first->next;

	   ListNode * pre = NULL;

       int i = 0;

       while(i<k-2&&end!=NULL)//end要指向第k个节点

       {

           end = end->next;

           i++;

        }

       while(NULL != end)

       {

            if(first == head)//仅仅有一次

                head = end;

	   else pre->next = end;

            reverse(first,end);

			pre = first;

            first = first->next;

			if(first == NULL)

				break;

			end = first->next;

            i =0;

            while(i<k-2&&end!=NULL)

            {

                end = end->next;

                i++;

            }

       }

       return head;

    }

};