牛客-NC50-链表中的节点每k个一组翻转

方法一：指针法

写在前面：这道题考察分段链表的反转问题，个人认为比较难的在于如何使用指针将翻转部分，待翻转部分连接起来，链表题就是这样，需要的指针一多，脑袋就有点发晕了。尽管反转单链表已经写得滚瓜烂熟，但这道题的细节太多了，在LeetCode上这是道hard题目，链接，自己只能参考比较优质的题解，图解k个一组翻转链表。
思路：

1. 翻转的范围，只能通过k次循环来确定。
2. 初始化两个指针pre和end,pre表示待翻转链表的前驱节点，end代表待翻转链表的尾节点。
3. 经过k次循环，end指针到达尾节点，使用指针start记录要翻转链表的头节点，使用指针next记录end.next，方便后面连接未翻转链表，并将end.next = null来断开链表。
4. 将指针start指向的头节点送入翻转函数中，完成翻转，并让pre.next指向翻转后的链表。
5. 此时，需要将start.next = next（start已经变成翻转链表的尾节点）来将链表重新连接，需要注意的是，此时start也是待翻转链表的前驱节点。所以需要将pre指针指向start以及将end置为下次要翻转的链表的头节点的上一个节点，也就是start。

可以写出以下代码：

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
        // 定义一个假的节点
        ListNode dummy = new ListNode(0);
        // 假节点的next指向head。
        // dummy -> 1 -> 2 -> 3 -> 4 -> 5 -> null
        dummy.next = head;
        // 初始化pre和end都指向dummy。
        // pre指每次要翻转的链表的头节点的上一个节点。
        // end指每次要翻转的链表的尾节点。
        ListNode pre = dummy;
        ListNode end = dummy;

        while (end.next != null) {
            /*1*/
            // 循环k次，找到需要翻转的链表的结尾，这里每次循环要判断end是否等于空，
            // 因为如果为空，end.next会报空指针异常。
            // dummy->1->2->3->4->5->null 若k为2，循环2次，end指向2
            for (int i = 0; i < k && end != null; i++) {
                end = end.next;
            }
            // 如果end==null，即需要翻转的链表的节点数小于k，不翻转。
            if (end == null) break;
            /*2*/
            // 记录要翻转链表的头节点
            ListNode start = pre.next;
            // 先记录下end.next，方便后面连接链表
            ListNode next = end.next;
            // 然后断开链表
            end.next = null;
            /*3*/
            // 翻转链表，pre.next指向翻转后的链表。1->2变成2->1。dummy->2->1
            pre.next = reverse(start);
            // 翻转后头节点变到最后。通过.next把断开的链表重新连接。
            start.next = next;
            // 将pre换成下次要翻转的链表的头节点的上一个节点。即start
            pre = start;
            // 翻转结束，将end置为下次要翻转的链表的头节点的上一个节点。即start
            end = pre;
        }
        return dummy.next;
    }
    public ListNode reverse(ListNode node) {
        ListNode pre = null;
        ListNode cur = node;
        while (cur != null) {
            ListNode tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
}

时间复杂度： O(n * K)，最好情况下是O(n)，最差情况下是O(n²)。
空间复杂度： O(1)，除开几个必须的指针，并未使用其他空间。