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.

k is a positive integer and is less than or equal to the length of the linked 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个一组翻转链表迭代求解，最后剩下的顺序不变。
翻转链表时采取头插法，先删除待插入节点，再插入。
注意维护3个指针变量，头指针、当前指针、待插入指针。

/**
 * 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 dummy(0);
        dummy.next=head;
        ListNode *pre=&dummy,*cur=pre;
        int num=0;
        while(cur=cur->next) num++;
        while(num>=k){
            cur=pre->next;
            for(int i=1;i<k;i++){
                ListNode *t=cur->next;
                cur->next=t->next;
                t->next=pre->next;
                pre->next=t;
            }
            pre=cur;
            num-=k;
        }
        return dummy.next;
    }
};

方法二：递归法。
用head记录每段的开始位置，cur记录结束位置的下一个节点，调用reverse来将这段翻转，得到一个new_head，原来的head就变成了末尾，这时候后面接上递归调用下一段得到的新节点，返回new_head即可。
这里的reverse和上面不同，每次把头结点head和尾节点pre相连,并更新pre和head，head向后移动，pre向前移动，直到head移动到tail结束。

/**
 * 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 *cur=head;
        for(int i=0;i<k;i++){
            if(!cur) return head;
            cur=cur->next;
        }
        ListNode *new_head=reverse(head,cur);
        head->next=reverseKGroup(cur,k);
        return new_head;
    }
    ListNode* reverse(ListNode *head,ListNode *tail){
        ListNode *pre=tail;
        while(head!=tail){
            ListNode *t=head->next;
            head->next=pre;
            pre=head;
            head=t;
        }
        return pre;
    }
};