力扣第二十五题-K 个一组翻转链表

前言

力扣第二十五题 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]

一、思路

这一题很明显可以使用递归来解决，函数自身只需要处理前K个节点的反转即可。

那么如何反转当前链表的前K个节点呢？这里有两种方式来处理：

1. 读取前K个节点并存到List中，遍历List重组链表
2. 使用头插法原地修改，无需更多的存储空间

第一种实现方案相对来说比较简单，看下方的实现代码应该就能明白意思了。所以在这里重点讲一下使用头插法反转链表

tips：头插法无需额外的存储空间，执行速度会更快！推荐使用⭐⭐⭐

使用头插法的思想就是新节点始终作为新链表的头部，它的具体步骤如下所示（本来想画图的，试着画了一下感觉画图没办法说清楚）：

1. next 指向 head.next
2. head.next 指向 pre（pre的初始值为 null）
3. pre 指向 head
4. head 指向 next
5. 只要链表还有下一个节点，则重复步骤 1~4

例子讲解

假设链表为 1->2->3

1. next 指向 head.next，next 指向结果为 2->3
2. head.next 指向 pre，此时 head 指向的结果为 1->null
3. pre 指向 head，此时 pre 的结果为 1->null
4. head 指向 next，head 指向的结果为 2->3
5. 链表还有下一个节点，重复步骤1，next 指向结果为 3
6. 重复步骤2，head 指向的结果为 2->1
7. 重复步骤3，pre 的结果为 2->1
8. 重复步骤4，head 指向的结果为 3
9. …，以此类推。最终 pre 的结果为 3->2->1

二、实现

方案一

实现代码

    /**
     * 递归
     */
    public ListNode reverseKGroup(ListNode head, int k) {
        // 列表用于存储取出的节点
        List<ListNode> list = new ArrayList<>();
        ListNode headTemp = head;
        ListNode newHead = new ListNode();
        ListNode newHeadTemp = newHead;
        // 处理k个节点
        for (int i=0; i<k; i++) {
            if (headTemp == null) {
                return head;
            }
            list.add(headTemp);
            headTemp = headTemp.next;
        }
        for (int i=k-1; i > -1; i--) {
            newHeadTemp.next = list.get(i);
            newHeadTemp = newHeadTemp.next;
        }
        newHeadTemp.next = reverseKGroup(headTemp, k);
        return newHead.next;
    }

测试代码

    public static void main(String[] args) {
//        [1,2,3,4,5]
        ListNode l = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5)))));
        ListNode ret = new Number25().reverseKGroup(l, 2);
        System.out.println(ret);
    }

结果

方案二（原地反转）

实现代码

    /**
     * 递归
     * tips：原地修改会更快
     */
    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++) {
            if (tail == null) {
                return head;
            }
            tail = tail.next;
        }
        ListNode newHead = null;    // 新的头节点
        ListNode next;  // 下一个节点
        ListNode pre = head;
        while (pre != tail) {
            next = pre.next;
            pre.next = newHead;
            newHead = pre;
            pre = next;
        }
        head.next = reverseKGroup(tail, k);
        return newHead;
    }

结果

三、总结

感谢看到最后，非常荣幸能够帮助到你~♥