【LeetCode】K 个一组翻转链表

#LeetCode每日一题【链表专题】

• K 个一组翻转链表
  https://leetcode-cn.com/problems/reverse-nodes-in-k-group/
• 分析
  根据给定的k值，将原链表进行分组反转，剩余的不足k的保持不变
  我这边第一思路是求出了链表的长度，然后根据长度计算出分组数，再对每一组进行反转，最后相互拼接即可
• 实现

public ListNode reverseKGroup(ListNode head, int k) {
        int length = 0;
        ListNode temp = head;
        while (temp != null) {
            temp = temp.next;
            length++;
        }
        int count = length / k;
        ListNode ans = new ListNode(0);
        ListNode node = ans, prev = null, next;
        for (int i = 0; i < count; i++) {
            // 记录反转链表前的第一个元素是啥，也即反转之后的最后一个元素（常用于拼接）
            temp = head;
            for (int j = 0; j < k; j++) {
                next = head.next;
                head.next = prev;
                prev = head;
                head = next;
            }
            node.next = prev;
            // node指向temp，即让其指向反转之后的最后一个节点，利于拼接
            node = temp;
            // 重置prev
            prev = null;
        }
        node.next = head;
        return ans.next;
    }

LeetCode耗时：0ms

• 实现二
  巩固之前所学递归算法套路，又写了一套递归算法：
  每K的一组将原链表切分，不断递归，直到链表为空或者长度不足k递归结束；
  基于当前递归，将当前链表进行反转在拼接上一步返回的结果即可
• 递归实现

public ListNode reverseKGroup02(ListNode head, int k) {
        if (head == null) {
            return null;
        }
        ListNode node = head;
        for (int i = 0; i < k - 1; i++) {
            node = node.next;
            // 链表长度不足k
            if (node == null) {
                return head;
            }
        }
        ListNode p = node.next;
        node.next = null;
        ListNode ans = reverseKGroup02(p, k);
        // 反转标准模板，prev是反转之后的结果、head是反转之后的最后一个值
        ListNode prev = null, next, q = head;
        while (q != null) {
            next = q.next;
            q.next = prev;
            prev = q;
            q = next;
        }
        head.next = ans;
        return prev;
    }

LeetCode耗时：0ms

• 总结
  该题属于反转链表的变形题，会熟练应用反转链表的操作应该是挺好容易上手解决的；针对递归的方式，还是之前说的三部曲：找结束条件，找返回值，当前递归能拿到什么然后应该做什么