链表以k个一组进行翻转（2014美团研发笔试）

给出一个链表和一个数k，比如链表1→2→3→4→5→6，k=2，则翻转后2→1→4→3→6→5，若k=3,翻转后3→2→1→6→5→4，若k=4，翻转后4→3→2→1→5→6。

ListNode *reverseKGroup(ListNode *head, int k)
{
    if (head == nullptr || head->next == nullptr || k < 2)
        return head;
    ListNode *next_group = head;
    for (int i = 0; i < k; ++i)
    {
        if (next_group)
            next_group = next_group->next;
        else
            return head;
    }
// next_group is the head of next group
// new_next_group is the new head of next group after reversion
    ListNode *new_next_group = reverseKGroup(next_group, k);
    ListNode *prev = NULL, *cur = head;
    while (cur != next_group)
    {
        ListNode *next = cur->next;
        cur->next = prev ? prev : new_next_group;
        prev = cur;
        cur = next;
    }
    return prev; // prev will be the new head of this group
}

若末尾不足K的也进行翻转，则如下

/* Reverses the linked list in groups of size k and returns the
   pointer to the new head node. */
struct node *reverse (struct node *head, int k)
{
    struct node* current = head;
    struct node* next;
    struct node* prev = NULL;
    int count = 0;

    /*reverse first k nodes of the linked list */
    while (current != NULL && count < k)
    {
        next  = current->next;
        current->next = prev;
        prev = current;
        current = next;
        count++;
    }

    /* next is now a pointer to (k+1)th node
       Recursively call for the list starting from current.
       And make rest of the list as next of first node */
    if(next !=  NULL)
    {
        head->next = reverse(next, k);
    }

    /* prev is new head of the input list */
    return prev;
}

见Geeks、Leetcode