[LeetCode]025-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

Solution:
思路很简单，基础的就是链表的反转。然后将其中每一段需要反转的链表拿出来反转，再插入进去。

ListNode* reverseKGroup(ListNode* head, int k) 
    {
        if(k == 1 || head == NULL || head->next == NULL)
            return head;
        ListNode* pre = new ListNode(NULL);
        pre->next = head; //整个链表的前结点
        ListNode*pre_node = pre;//首个链表的前节点
        ListNode*post_node = head;//后节点

        ListNode* first;
        ListNode* last = head;
        int i =0;
        while(last !=NULL)
        {
            i++;
            if(i==k)//此时last指向末尾
            {
                post_node = last->next;//保存下一链表的后节点
                first = pre_node->next;
                reverse_list(first,last); //结束时head和tail反转了

                //反转结束，然后就前后插入链表。
                pre_node->next = last;
                first->next = post_node;

                pre_node = first; //更新下一链表组的前节点
                last = first;
                i = 0;
            }
            last = last->next;
        }
        return pre->next;
    }

    void reverse_list(ListNode* head,ListNode* tail)
    {
        //cout<<"XX"<<endl;
        ListNode* pre = new ListNode(NULL);
        ListNode* p = head;
        ListNode* q;
        pre->next = head;
        while(pre->next !=tail)
        {
            q = p->next;
            p->next = q->next;
            q->next = pre->next;
            pre->next = q;
        }
    }