数据结构与算法之深入解析“K个一组翻转链表”的求解思路与算法示例

Posted Serendipity·y

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了数据结构与算法之深入解析“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]
  • 提示:
    • 列表中节点的数量在范围 sz 内;
    • 1 <= sz <= 5000;
    • 0 <= Node.val <= 1000;
    • 1 <= k <= sz。

二、求解算法

① 模拟

  • 链表分区为已翻转部分+待翻转部分+未翻转部分;
  • 每次翻转前,要确定翻转链表的范围,这个必须通过 k 此循环来确定;
  • 需记录翻转链表前驱和后继,方便翻转完成后把已翻转部分和未翻转部分连接起来;
  • 初始需要两个变量 pre 和 end,pre 代表待翻转链表的前驱,end 代表待翻转链表的末尾;
  • 经过 k 此循环,end 到达末尾,记录待翻转链表的后继 next = end.next;
  • 翻转链表,然后将三部分链表连接起来,然后重置 pre 和 end 指针,然后进入下一次循环;
  • 特殊情况,当翻转部分长度不足 k 时,在定位 end 完成后,end==null,已经到达末尾,说明题目已完成,直接返回即可;

  • Java 示例:
public ListNode reverseKGroup(ListNode head, int k) 
    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.next;
        if (end == null) break;
        ListNode start = pre.next;
        ListNode next = end.next;
        end.next = null;
        pre.next = reverse(start);
        start.next = next;
        pre = start;

        end = pre;
    
    return dummy.next;


private ListNode reverse(ListNode head) 
    ListNode pre = null;
    ListNode curr = head;
    while (curr != null) 
        ListNode next = curr.next;
        curr.next = pre;
        pre = curr;
        curr = next;
    
    return pre;

② 递归

  • 找到待翻转的 k 个节点(注意:若剩余数量小于 k 的话,则不需要反转,因此直接返回待翻转部分的头结点即可)。
  • 对其进行翻转,并返回翻转后的头结点(注意:翻转为左闭又开区间,所以本轮操作的尾结点其实就是下一轮操作的头结点)。
  • 对下一轮 k 个节点也进行翻转操作;
  • 将上一轮翻转后的尾结点指向下一轮翻转后的头节点,即将每一轮翻转的 k 的节点连接起来。

  • Java 示例:
    public ListNode reverseKGroup(ListNode head, int k) 
        if (head == null || head.next == null) 
            return head;
        
        ListNode tail = head;
        for (int i = 0; i < k; i++) 
            //剩余数量小于k的话,则不需要反转。
            if (tail == null) 
                return head;
            
            tail = tail.next;
        
        // 反转前 k 个元素
        ListNode newHead = reverse(head, tail);
        //下一轮的开始的地方就是tail
        head.next = reverseKGroup(tail, k);

        return newHead;
    

    /*
    左闭又开区间
     */
    private ListNode reverse(ListNode head, ListNode tail) 
        ListNode pre = null;
        ListNode next = null;
        while (head != tail) 
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        
        return pre;

    

以上是关于数据结构与算法之深入解析“K个一组翻转链表”的求解思路与算法示例的主要内容,如果未能解决你的问题,请参考以下文章

打卡算法25 K 个一组翻转链表 算法解析

打卡算法25 K 个一组翻转链表 算法解析

Java 求解K 个一组翻转链表

js 之k个一组翻转链表

算法leetcode|25. K 个一组翻转链表(rust重拳出击)

算法leetcode|25. K 个一组翻转链表(rust重拳出击)