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

思路：遍历链表，计数到k 就翻转。 麻烦的是拼接

设置一个虚拟头结点，保证之后的逻辑一致。

比如 -1 1 2 3 4

p为正常遍历链表 num计数 到k执行翻转逻辑

q 可以想为 一条新链。

num == k 时

1. 记录下t = [3] 保证之后可以连接到后面
2. 翻转q.next 也就是 [1, 2] 这条链表 结果为 [2, 1]
3. 记录此时[2, 1] 的头尾节点 pre 为 [2] h 为 [1]
4. p.next = pre 也就是 [-1 , 2 , 1]
5. p = h; p 为 [1]
6. 连接旧的链表 p.next = t 此时为 [-1, 2, 1 ,3 , 4]
7. q = p.next, num = 1 重置 循环操作上面步骤

import java.util.*;

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

public class Solution {
    /**
     * 
     * @param head ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
  
    ListNode h = null;
    public ListNode reverseKGroup (ListNode head, int k) {
        // write code here
        if(head == null) {
            return null;
        }
        ListNode newhead = new ListNode(-1);
        ListNode p = head;
        ListNode q = newhead;
        q.next = p;
        int num = 1;
        while(p != null) {
            if(num == k) { 
                ListNode t = p.next;
                p.next = null;
                q.next = rersver(q.next);
                q = h;
                q.next = t;
                p = q.next;
                num = 1;
            }
            if(p != null) p = p.next;
            num++;
            
        }
        return newhead.next;
    }
    ListNode rersver(ListNode head) {
        ListNode pre = null, cur = head;
        while(cur != null) {
            ListNode  t = cur.next;
            cur.next = pre;
            pre = cur;
            cur = t;
        }
        h = head;
        return pre;
    }
}