Leetcode-25.Reverse Nodes in k-Group

Problem Description:
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

---

Analysis:
Since the head node might be modified, so I add a dummy node before the head called newhead.
First we need count the node’s num, if it is smaller than K, we just return the Listnode, else we use head insert
to implement the reverse. However we need to save the TAIL of the Kth node.This node will be the newhead of the next loop.

  ListNode* reverseKGroup(ListNode* head, int k) {
    if (!head || !head -> next || k == 1) return head;
    // ListNode newhead(-1);
    // newhead.next = head;
    // ListNode * cur = & newhead; Avoid leak memory
    ListNode * newhead = new ListNode (-1);
    ListNode * p = newhead;
    newhead -> next = head;
    while (p){
    ListNode *t = p;
    for (int i = 0; i < k && t; i++)
        t = t -> next;
    if (!t) return newhead -> next;
    p = swapNode(p, k); // return the tail!
    }
    return newhead -> next;
 }
    ListNode* swapNode(ListNode *p, int k)// return the tail 
    {
        ListNode * tail = p -> next;
        ListNode * q = tail -> next;
        for (int i = 1; i < k; ++i)
        {
            tail -> next = q -> next;//keep the connection with the following nodes.
            q -> next = p -> next;
            p -> next = q;
            q = tail -> next; 
        }
        return tail;
    }
};

we can write even shorter code :