​力扣解法汇总25-K 个一组翻转链表

原题链接：力扣

描述：

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

进阶：

你可以设计一个只使用常数额外空间的算法来解决此问题吗？
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：

 

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]
示例 2：

输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]
示例 3：

 

输入：head = [1,2,3,4,5], k = 1
输出：[1,2,3,4,5]
示例 4：

输入：head = [1], k = 1
输出：[1]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路：

反转链表一定要溯洄的概念，所以递归是肯定了。

但是本题的难点就是如果数量不够则不执行溯洄，以及要返回溯洄后的头节点。

所以我的解题思路是构造一个数组，长度为3，代表返回值。

位置0时：反转后的头节点

位置1时：下一个循环的头节点

位置2时：这个其实是一个标记位，不为空时代表数量够，可以反转，再去执行反转操作。

代码：

 public ListNode reverseKGroup(ListNode head, int k) {
        //0:反转后的头节点，1:下一个头节点，2:k数量是否够
        ListNode[] fanzhuan;
        ListNode result = null;
        ListNode lastNode = null;//
        do {
            fanzhuan = fanzhuan(head, k);
            if (lastNode != null) {
                lastNode.next = fanzhuan[0];
            }
            lastNode = head;
            if (result == null) {
                result = fanzhuan[0];
            }
            head = fanzhuan[1];
        } while (head != null);
        return result;
    }

    public ListNode[] fanzhuan(ListNode node, int k) {
        if (k == 1) {
            return new ListNode[]{node, node.next, node};
        }
        if (node == null || node.next == null) {
            return new ListNode[]{node, null, null};
        }
        ListNode[] topNode = fanzhuan(node.next, k - 1);
        if (topNode[2] != null) {
            node = exchange(node, node.next);
            node.next.next = null;
            return topNode;
        }
        return new ListNode[]{node, null, null};//5
    }

    //交换链表节点
    public ListNode exchange(ListNode node1, ListNode node2) {
        node1.next = node2.next;
        node2.next = node1;
        return node2;
    }