【算法】K个一组翻转链表

【算法】K个一组翻转链表

出处

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

题解地址可参考：https://leetcode-cn.com/problems/reverse-nodes-in-k-group/solution/k-ge-yi-zu-fan-zhuan-lian-biao-by-leetcode-solutio/

题目

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

思路

我们可以使用一个指针 head 依次指向每组的头节点。这个指针每次向前移动 k 步，直至链表结尾。

对于每个分组，我们先判断它的长度是否大于等于 k。若是，我们就翻转这部分链表，否则不需要翻转。

如何翻转一个分组内的子链表？

翻转一个链表并不难，过程可以参考「206. 反转链表」。但是对于一个子链表，除了翻转其本身之外，还需要将子链表的头部与上一个子链表连接，以及子链表的尾部与下一个子链表连接。

在翻转子链表的时候，我们不仅需要子链表头节点 head，还需要有 head 的上一个节点 pre，以便翻转完后把子链表再接回 pre。

我们先新建一个节点，把它接到链表的头部，让它作为 pre 的初始值，这样 head 前面就有了一个节点，我们就可以避开链表头部的边界条件。

反复移动指针 head 与 pre，对 head 所指向的子链表进行翻转，直到结尾，我们就得到了答案。

代码

public class M {
    public ListNode reverseKGroup(ListNode head, int k) {
        // 定义一个哑结点
        ListNode hair = new ListNode(0);
        // 哑结点的next指向head结点
        hair.next = head;
        // 定义一个pre结点，指向哑结点
        ListNode pre = hair;

        while (head != null) {
            // 定义一个尾结点，指向pre结点
            ListNode tail = pre;
            // 循环K次，每次都将尾结点指针后移一位
            for (int i = 0; i < k; ++i) {
                tail = tail.next;
                // 如果尾结点为null，则说明已经遍历完所有结点，则直接返回哑结点的next结点即可
                if (tail == null) {
                    return hair.next;
                }
            }
            // 定义一个nex结点，指向当前尾结点的next结点
            ListNode nex = tail.next;
            // 翻转链表，
            ListNode[] reverse = myReverse(head, tail);
            // head和tail交换
            head = reverse[0];
            tail = reverse[1];
            // 把子链表重新接回原链表
            pre.next = head;
            tail.next = nex;
            // pre指向tail ， head，指向tail的next
            pre = tail;
            head = tail.next;
        }

        return hair.next;
    }

    /**
     * 翻转链表
     **/
    public ListNode[] myReverse(ListNode head, ListNode tail) {
        // prev结点，指向尾结点的下一个结点
        ListNode prev = tail.next;
        // p结点，指向head结点
        ListNode p = head;
        while (prev != tail) {
            // nex结点，指向p的next
            ListNode nex = p.next;
            p.next = prev;
            prev = p;
            p = nex;
        }
        return new ListNode[]{tail, head};
    }
}

class ListNode {
    int val;
    ListNode next;

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
    
    ListNode(int val) {
        this.val = val;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70