LeetCode25 - K 个一组翻转链表

LeetCode25 - K 个一组翻转链表

链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group

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

解法一、时间复杂度O(nk)，空间复杂度O(k)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(head == null || head.next == null || k<=1) return head;
        // 虚拟节点+移动节点
        ListNode vHead = new ListNode(-1);
        ListNode mNode = vHead;
        // 栈
        Stack<ListNode> stack = new Stack<>();
        while(head != null) {
            while(head != null && stack.size() < k) {
                stack.push(head);
                head = head.next;
            }
            // 最后一批
            if(stack.size() != k) {
                break;
            }
            for(int i=0; i<k; i++) {
                mNode.next = stack.pop();
                mNode = mNode.next;
            }
            mNode.next = null;
        }
        if(!stack.isEmpty()) {
            mNode.next = stack.get(0);
        }
        return vHead.next;
    }
}

解法二、时间复杂度O(n)，空间复杂度O(1)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {

    public ListNode reverseKGroup(ListNode head, int k) {
        if(head == null || head.next == null || k<=1) return head;
        // 虚拟节点
        ListNode vHead = new ListNode(-1);
        vHead.next = head;
        ListNode pre = vHead;
        while(head != null) {
            ListNode tail = pre;
            // 查看剩余部分是否大于k
            for(int i=0; i<k; i++) {
                tail = tail.next;
                if(tail == null) {
                    return vHead.next;
                }
            }
            ListNode temp = tail.next;
            // 在 head ~ tail这段范围翻转
            ListNode[] rangeReverse = reverse(head, tail);
            head = rangeReverse[0];
            tail = rangeReverse[1];
            // 接入主链
            pre.next = head;
            tail.next = temp;
            // 继续下个k链
            pre = tail;
            head = tail.next;
        }
        return vHead.next;
    }

    private ListNode[] reverse(ListNode head, ListNode tail) {
        // 一般的翻转，prev设置为null，这里是为了控制翻转的范围
        ListNode prev = tail.next;
        ListNode p = head;
        while(prev != tail) {
            ListNode temp = p.next;
            p.next = prev;
            prev = p;
            p = temp;
        }
        return new ListNode[]{tail, head};
    }
}

小总结：
1.利用栈控制翻转的范围，占用额外K个空间
2.利用prev = tail.next; while(prev != tail) 控制翻转的范围