K 个一组翻转链表11

 

题目描述

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

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

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

提示：

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

解题思路

K 个一组翻转链表问题可以使用递归或迭代的方法来实现。其中，迭代方法比递归方法更优，因为递归方法在处理大规模数据时容易出现栈溢出的问题。

迭代方法的基本思路是，每 k 个节点为一组进行翻转，如果剩余节点不足 k 个，则保持原有顺序不变。具体实现时，需要使用 3 个指针：pre、end 和 next，其中 pre 表示待翻转区域的前驱节点，end 表示待翻转区域的后继节点，next 则是遍历链表的指针。

具体步骤如下：

1. 初始化指针 pre 为 null，指针 end 和指针 next 均指向头节点 head。
2. 对于每个 k 个节点为一组的区间，执行以下操作：
   • 从当前位置开始，将指针 next 向后移动 k 个节点，如果剩余节点不足 k 个，则不进行翻转。
   • 使用 end 指针记录当前待翻转区域的后继节点。
   • 使用 next 指针记录当前待翻转区域的下一个节点。
   • 将当前待翻转区域翻转，并返回翻转后的头节点。具体操作可参考翻转链表。
   • 如果 pre 为 null，说明当前翻转区域为链表的第一组，需要更新链表头节点为翻转后的头节点，否则将翻转后的头节点接到 pre 的后面。
   • 将 pre 更新为当前翻转区域的尾节点，即指针 end。
   • 将指针 end 更新为 next，继续处理下一组待翻转区域。
3. 返回翻转后的链表头节点。

时间复杂度为 O(n)，其中 n 为链表的长度，空间复杂度为 O(1)。

具体代码展示

package org.zyf.javabasic.letcode.list.application;

import org.zyf.javabasic.letcode.list.base.ListNode;

/**
 * @author yanfengzhang
 * @description 给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
 * k 是一个正整数，它的值小于或等于链表的长度。
 * 如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
 * 示例：输入：head = [1,2,3,4,5], k = 2.       输出：[2,1,4,3,5]
 * 输入：head = [1,2,3,4,5], k = 3        输出：[3,2,1,4,5]
 * <p>
 * 提示：
 * 链表中节点的数量在范围 sz 内，1 <= sz <= 5000
 * 0 <= Node.val <= 1000
 * 1 <= k <= sz
 * @date 2023/4/5  23:32
 */
public class ReverseKGroup {

    /*解法：
     * 使用迭代法实现链表翻转，每 k 个节点为一组，处理完后将前后两组连接起来。
     * 具体实现时，使用 pre 指向待翻转链表的前一个节点，end 指向待翻转链表的尾部节点，
     * 然后遍历链表，处理 k 个节点为一组的子链表，将其翻转，并将翻转后的头节点与前面的子链表连接，
     * 并将 pre 指向下一组子链表的头节点的前一个节点，end 指向下一组子链表的尾部节点，
     * 直到链表遍历完成。
     *
     * 时间复杂度：O(n)，其中 n 是链表的长度。head 节点会在 O(n/k) 段中被翻转，每次翻转的时间复杂度是 O(k)。
     * 空间复杂度：O(1)。*/
    public ListNode reverseKGroup(ListNode head, int k) {
        /*如果链表为空、链表只有一个元素或k=1，则直接返回原链表*/
        if (head == null || head.next == null || k == 1) {
            return head;
        }

        /*dummy节点可以避免很多判断和特殊处理，所以一般在链表题目中都会用到*/
        ListNode dummy = new ListNode(0);
        dummy.next = head;

        /*每一段翻转前的前一个节点*/
        ListNode pre = dummy;
        /*每一段翻转后的尾节点*/
        ListNode end = dummy;

        while (end.next != null) {
            for (int i = 0; i < k && end != null; i++) {
                /*将end指针移动到需要翻转的段的最后一个节点*/
                end = end.next;
            }
            if (end == null) {
                break;
            }

            /*每一段翻转前的第一个节点*/
            ListNode start = pre.next;
            /*记录下一段翻转前的第一个节点*/
            ListNode next = end.next;
            /*切断当前段和下一段的连接，便于翻转当前段*/
            end.next = null;

            /*翻转当前段*/
            pre.next = reverse(start);
            /*连接上一段和当前段，连接当前段和下一段*/
            start.next = next;

            /*将pre、end移动到下一段翻转前的位置*/
            pre = start;
            end = start;
        }

        return dummy.next;
    }

    /**
     * 翻转链表
     */
    private ListNode reverse(ListNode head) {
        ListNode prev = null;
        ListNode cur = head;
        while (cur != null) {
            ListNode next = cur.next;
            cur.next = prev;
            prev = cur;
            cur = next;
        }
        return prev;
    }

    public static void main(String[] args) {
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(4);
        head.next.next.next.next = new ListNode(5);
        int k = 2;
        System.out.println("Original List: " + printLinkedList(head));
        head = new ReverseKGroup().reverseKGroup(head, k);
        System.out.println("Reversed List: " + printLinkedList(head));
    }

    private static String printLinkedList(ListNode head) {
        StringBuilder res = new StringBuilder();
        while (head != null) {
            res.append(head.val).append(" -> ");
            head = head.next;
        }
        res.append("null");
        return res.toString();
    }


}

from：链表知识及编程练习总结_链表结构的定义,包含两个成员分别用于保存数据和指向下一个结点的代码-CSDN博客