题解 | #链表中的节点每k个一组翻转#

public ListNode reverseKGroup(ListNode head, int k) {
        //特殊情况判断
        //k =1
        if (k == 1 || k == 0 || head == null || head.next == null) return head;
        //拿到链表的长度
        int size = 1;
        ListNode tempHead = head;
        while (tempHead.next != null){
            tempHead = tempHead.next;
            size ++ ;
        }
        //判断k与size是否相等
        if(k == size) return ReverseList(head);
        //计算一共需要反转多少组
        int count = size/k;
        int point = 1;
        //记录要反转的首节点的数字
        int first = 0;
        //记录要反转的尾节点的数字
        int last = 0;
        //记录反转的次数
        int reverseCount = 0;
        while(point <= size){
            if(reverseCount == count){
                break;
            }
            if(point % k == 1){
                //找到反转的首节点
                first = point;
            }
            if(point % k == 0){
                //找到反转的尾节点
                last = point;
                //执行反转
                head = reverseBetween(head,first,last);
                reverseCount ++ ;
            }
            point ++ ;
        }
        return head;
}
public ListNode reverseBetween(ListNode head, int m, int n) {
        //定义返回结果
        ListNode resultHead = head;
        //当m == n时 直接返回首节点
        if (m == n) {
            return head;
        }
        //找到m之前的节点和n之后的节点 以及m和n两个位置的节点
        ListNode mNode = null;
        ListNode preNode = null;
        ListNode tempNode = null;
        ListNode lastNode = null;
        //正常情况  m n 不是首节点和尾节点的情况
        //定义指针变量 用来计数
        int i = 1;
        while (i < n) {
            //已经排除m与n相等的情况，可以直接先找到m
            if (i == m) {
                //存在一种特殊情况，当m=1 此时preNode直接就是首届点
                //此时可以为mNode赋值
                preNode = tempNode;
                mNode = head;
            }
            //记录上一个节点
            tempNode = head;
            head = head.next;
            i++;
        }
        //循环结束，进入m之前的节点和n出来之后的节点都可以计算出来
        if (head.next != null) {
            lastNode = head.next;
            head.next = null;
        }
        //开始反转
        ListNode reverse = ReverseList(mNode);
        //反转结束 确定反转后m和n位置的节点
        if (preNode == null) {
            //说明m就是首节点的位置
            resultHead = reverse;
        } else {
            preNode.next = reverse;
        }
        if (lastNode != null) {
            while (reverse.next != null) {
                reverse = reverse.next;
            }
            //说明n就是首页点的位置，不需要做任何操作
            reverse.next = lastNode;
        }
        return resultHead;
}
public ListNode ReverseList(ListNode head) {
        if (head == null || head.next == null) {
            //当确保时节点的最后一个节点时作为方法返回值返回
            return head;
        }
        ListNode resultNode = ReverseList(head.next);
        head.next.next = head;
        head.next = null;
        return resultNode;
}

解题思路：
1、利用BM1和BM2两道题目的方法进行解题
2、特殊情况做特殊处理，一般特殊情况下都是直接返回原链表即可
3、排除特殊情况之后查询出链表的总长度，计算出一共要反转的次数，利用循环找出要进行反转的位置点
4、将找到的位置点以及head作为参数传入BM2的方法中即可