25. K 个一组翻转链表（java实现）--2种解法（迭代，递归）LeetCode

题目：

给你一个链表，每 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]

提示：

列表中节点的数量在范围 sz 内
1 <= sz <= 5000
0 <= Node.val <= 1000
1 <= k <= sz

解法1：迭代

    /**
     * 思路：
     * 每k个节点反转一次
     * 用count记录当前节点数，每k个节点的时候归零一次
     * 用反转后的尾节点指向下个节点next
     * 反转前一定要让当前的尾节点指向null，方便进行反转
     * 设置前驱节点pre，始终指向反转后的头结点
     * 不断循环这个过程，直到curr==null
     */
    public static ListNode reverseKGroup(ListNode head, int k) {
        int count = 0;
        ListNode pre = new ListNode(-1);
        ListNode dummy = pre;
        pre.next = head;
        ListNode curr = head;
        while (curr != null) {
            if (count == k - 1) {
                ListNode next = curr.next;
                curr.next = null;
                count = 0;
                curr = reverse(head);
//                curr=reverse_pre(head);
//                curr=reverse_recursive(head);
                pre.next = curr;
                head.next = next;
                pre = head;
                head = next;
                curr = next;
            } else {
                curr = curr.next;
                count++;
            }
        }
        return dummy.next;
    }
    private static ListNode reverse(ListNode head) {
        if (head == null) {
            return head;
        }
        ListNode curr = head;
        ListNode next = curr.next;
        while (next != null) {
            ListNode nn = next.next;
            next.next = curr;
            head.next = nn;
            curr = next;
            next = nn;
        }
        return curr;
    }

    private static ListNode reverse_pre(ListNode head) {
        ListNode pre = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode next = curr.next;
            curr.next = pre;
            pre = curr;
            curr = next;
        }
        return pre;
    }

    private static ListNode reverse_recursive(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode tail = reverse_recursive(head.next);
        head.next.next = head;
        head.next = null;
        return tail;
    }

时间复杂度：On

空间复杂度：O1

解法2：递归

    /**
     * 思路：
     * 递归的确定每一组
     * 之后就反转每一组
     *
     * 首先走到下一组的头节点
     * 判断这个过程中进行了几次操作
     *      如果比k小，直接返回头节点，说明当前节点不够成组
     *      比k大继续，说明已经成组了，继续找下一组
     * 进行反转，头结点指向下一组的头节点，nextGroup_reverseHead和head进行移动，重新指向k次
     *
     */
    public static ListNode reverseKGroup(ListNode head, int k) {
        int count=0;
        ListNode nextGroup_head = head;
        while (count!=k&&nextGroup_head!=null){
            nextGroup_head=nextGroup_head.next;
            count++;
        }
        if (count!=k){
            return head;
        }else {
            ListNode nextGroup_reverseHead = reverseKGroup(nextGroup_head, k);
            while (count!=0){
                ListNode next = head.next;
                head.next=nextGroup_reverseHead;
                nextGroup_reverseHead=head;
                head=next;
                count--;
            }
            return nextGroup_reverseHead;
        }
    }

时间复杂度：On

空间复杂度：On