算法---LeetCode 25. K 个一组翻转链表

1. 题目

原题链接

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

2. 题解

2.1 解法1: 迭代翻转

主要思想:

每次截取 k 个结点进行翻转, 然后连接, 循环

注意: 若要求不足 k 个结点也要翻转, 在判断中增加如下两行代码即可:

            ListNode start=reverse(pre.next);
            pre.next=start;

写法1:

    class Solution {
        public ListNode reverseKGroup(ListNode head, int k) {
            if (head == null) {
                return null;
            }
            ListNode dummy = new ListNode(0);
            dummy.next = head;
            // pre 指向待翻转链表的前一个结点, end为每次翻转完成后链表的尾结点
            ListNode pre = dummy;
            ListNode end = dummy;
            while (end != null) {
                // 选取出待翻转范围
                for (int i = 0; i < k && end != null; i++) {
                    end = end.next;
                }
                // 不足 k 个
                if (end == null) {
                    // 若不足k 个也要翻转, 则增加如下两行代码
                    //ListNode start=reverse(pre.next);
                    //pre.next=start;
                    return dummy.next;
                }
                ListNode next = end.next;
                ListNode reverseHead = pre.next;

                // 断链
                pre.next = null;
                end.next = null;
                // 翻转后的尾结点即为翻转前的头结点, 连接
                reverse(reverseHead);
                pre.next = end;
                reverseHead.next = next;
                // 此次反转完成, 重置pre, end 为待翻转链表的前驱
                pre = reverseHead;
                end = reverseHead;
            }
            return dummy.next;

        }

        public ListNode reverse(ListNode head) {
            if (head == null) {
                return null;
            }
            ListNode pre = null;
            ListNode curr = head;
            while (curr != null) {
                ListNode temp = curr.next;
                curr.next = pre;
                pre = curr;
                curr = temp;
            }
            return pre;
        }

    }

写法2:

    class Solution {
        public ListNode reverseKGroup(ListNode head, int k) {
            if (head == null) {
                return null;
            }
            ListNode dummy = new ListNode(0);
            dummy.next = head;
            // pre 指向待翻转链表的前一个结点, end为每次翻转完成后链表的尾结点
            ListNode pre = dummy;
            ListNode end = dummy;
            while (end.next != null) {
                // 选取出待翻转范围
                for (int i = 0; i < k && end != null; i++) {
                    end = end.next;
                }
                // 不足 k 个
                if (end == null) {
                    // 若不足k 个也要翻转, 则增加如下两行代码
                    //ListNode start=reverse(pre.next);
                    //pre.next=start;
                    reverse(pre.next);
                    return dummy.next;
                }
                ListNode next = end.next;
                end.next = null;
                // 翻转后的尾结点即为翻转前的头结点
                end = pre.next;
                ListNode start = reverse(end);
                pre.next = start;
                end.next = next;
                // 此次反转完成, 重置pre, end
                pre = end;
            }
            return dummy.next;

        }

        public ListNode reverse(ListNode head) {
            if (head == null) {
                return null;
            }
            ListNode pre = null;
            ListNode curr = head;
            while (curr != null) {
                ListNode temp = curr.next;
                curr.next = pre;
                pre = curr;
                curr = temp;
            }
            return pre;
        }

    }

参考:
图解k个一组翻转链表