将给出的链表中的节点每\ k k 个一组翻转，返回翻转后的链表
如果链表中的节点数不是\ k k 的倍数，将最后剩下的节点保持原样
你不能更改节点中的值，只能更改节点本身。
要求空间复杂度 \ O(1) O(1)
例如：
给定的链表是1\to2\to3\to4\to51→2→3→4→5
对于 \ k = 2 k=2, 你应该返回 2\to 1\to 4\to 3\to 52→1→4→3→5
对于 \ k = 3 k=3, 你应该返回 3\to2 \to1 \to 4\to 53→2→1→4→5

方法：我感觉自己走了弯路，完全通过指定多个变量和画图来实现的。
其中重要的是用链表的头插法。
思路：
对输入的链表，先求其长度num, num/k的值，就是其中子链表要反转的次数。
我指定了三个变量。
newHead是我新建的头节点，为了保存刚开始的初始位置。
Q初始为NULL，用来作为媒介通过头插法插在最后。
newHead1初值赋值为newHead,用来遍历联通后续链表的。
返回newHead.next；（newHead不算）
然后剩下的其他，自己画个图跟着走一片就知道了，我一头热搞出来的，运行效率低，望大佬们给出更好的！

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param head ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
public ListNode reverseKGroup(ListNode head, int k) {
        // write code here
        int num = count(head);
        if (num == 0 || num < k) {
            return head;
        }
        ListNode newHead = new ListNode(0);
        ListNode newHead1 = newHead;
        ListNode Q = null;
        ListNode p = head;
        ListNode q = head;
        int times = num / k;
        int i = 1;
        int j;
        while (i <= times) {
            j = 1;
            while (p != null && j <= k) {
                q = p.next;
                p.next = Q;
                Q = p;
                p = q;
                j++;
            }
            i++;
            newHead1.next = Q;
            while (newHead1.next != null) {
                newHead1 = newHead1.next;
            }
            while (Q != null) {
                Q = Q.next;
            }
            newHead1.next = p;

        }
        return newHead.next;
    }

    public int count(ListNode head) {
        ListNode l = head;
        int num = 0;
        while (l != null) {
            num++;
            l = l.next;
        }
        return num;

    }
}