可视化图解算法：链表中的节点每k个一组翻转（反转）

1. 题目

描述

将给出的链表中的节点每 k 个一组翻转，返回翻转后的链表。
如果链表中的节点数不是 k 的倍数，将最后剩下的节点保持原样。
你不能更改节点中的值，只能更改节点本身。

数据范围：2000 0≤n≤2000 ， 20001≤k≤2000 ，链表中每个元素都满足 10000≤val≤1000
要求空间复杂度 O(1)，时间复杂度 O(n)

例如：

给定的链表是 1→2→3→4→5

对于k=2 , 你应该返回 2→1→4→3→5

对于k=3 , 你应该返回3→2→1→4→5

示例1

输入：

{1,2,3,4,5},2

返回值：

{2,1,4,3,5}

示例2

输入：

{},1

返回值：

{}

2. 解题思路

假如链表如下图所示，给定的k=2。链表中每两个节点一组进行翻转。即对每一组内的k个节点进行反转（1与2进行反转，3与4进行反转），之后将每组内反转好的节点连接起来。

原链表是 1→2→3→4→5，翻转之后的链表 是2→1→4→3→5，结构如下图所示：

本题的难点是对一组反转之后的链表节点如何连接。

第一步：获取链表长度。

在此过程中需要定义一个虚拟头节点，让其链接到链表的头部，主要是方便返回（这时直接返回此虚拟头结点的下一个节点）。

tmpHead为临时虚拟头节点，now指针变量的作用：衔接 每组翻转之后的链表。

第二步：进行groups组的反转。

groups= 链表的长度 整除 k。总共有groups组需要反转，因此循环执行groups的反转。对每一group组k个节点进行翻转进行翻转可以依据链表反转一篇讲解的进行。

对第一组内的2个节点进行进行反转，结构如下图所示：

第一组内的2个节点反转之后，指针变量指向如下所示：

这时，要更改虚拟头节点的指向，因为虚拟头结点最终要指向反转之后链表的头结点的。指向如下图所示：

接下来需要指定指针变量now，确保它指向已经反转完的最后一个节点，便于衔接下一组反转的节点。

之后再对第2组的两个节点进行反转，结构如下图所示：

第二组的3与4节点反转完成之后，示意图如下所示：

现在第一组、第二组都完成了组内反反转，将两组的链表链接起来，注意是：1要链接到4。示意图如下所示：

最后再来移动指针变量的指向：

第三步：衔接剩余的节点。

反转完成之后，可能还有剩余的链表节点（如反转k组之后，剩余没有反转的节点），这时需要将剩余的节点与已经反转的连接起来。

两个组内的链表节点完成了反转，结构如下所示：

此时，还剩1个节点，不够k（k=2）个一组。因此需要将剩余的节点5链接到已经处理好的链表尾部就可以，连接如下图所示（红线指向）。

这样一来，就完成了链表按照k（此时k=2）个一组进行了反转（即：原链表是 1→2→3→4→5，翻转之后的链表 是2→1→4→3→5）。

如果文字描述的不太清楚，你可以参考视频的详细讲解。

• Python版本：https://www.bilibili.com/cheese/play/ep1370259
• Java版本：https://www.bilibili.com/cheese/play/ep1366715
• Golang版本：https://www.bilibili.com/cheese/play/ep1364392

3. 编码实现

3.1 Python编码实现

class ListNode:
    def __init__(self, x):
        self.val = x  # 链表的数值域
        self.next = None  # 链表的指针域


# 从链表节点尾部添加节点
def insert_node(node, value):
    if node is None:
        print("node is None")
        return
    # 创建一个新节点
    new_node = ListNode(value)
    cur = node
    # 找到链表的末尾节点
    while cur.next is not None:
        cur = cur.next
    # 末尾节点的next指针域连接新节点
    cur.next = new_node


# 打印链表（从链表头结点开始打印链表的值）
def print_node(node):
    cur = node
    # 遍历每一个节点
    while cur is not None:
        print(cur.val, end="\t")
        cur = cur.next  # 更改指针变量的指向
    print()



def get_list_len(head):
    # 链表长度：链表节点数量
    node_len = 0
    cur = head
    while cur is not None:
        node_len += 1
        cur = cur.next
    return node_len


#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param head ListNode类
# @param k int整型
# @return ListNode类
#
class Solution:
    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
        # write code here
        if k <= 1:
            return head
        # 1.获取链表长度，定义虚拟头结点、指针变量
        list_len = get_list_len(head)  # 获取链表长度
        groups = list_len // k  # 进行groups组翻转
        tmp_head = ListNode(-1)  # 临时虚拟头节点
        now = tmp_head  # 衔接 每组翻转之后的链表

        # 2. 进行groups组的反转
        # 2.1 定义每组连接节点反转的指针变量
        cur = head  # 每组反转的头节点
        nxt = head  # 每组反转（操作的）下一个节点
        pre = None  # 每组反转（操作的）前序节点
        for i in range(groups):
            # 2.2 对每一组k个节点进行翻转进行翻转
            for j in range(k):
                nxt = cur.next
                cur.next = pre
                pre = cur
                cur = nxt
            # 2.3 翻转之后，进行衔接
            now.next = pre  # 如果i==0时（第一次翻转），tmpHead、now为同一个节点
            while now.next is not None:
                now = now.next
            # 2.4 每一组K个节点反转完成后，使反转（操作的）前序节点指向空(Null)
            pre = None
        # 3. 衔接剩余的节点
        now.next = cur
        return tmp_head.next


if __name__ == '__main__':
    root = ListNode(1)
    insert_node(root, 2)
    insert_node(root, 3)
    insert_node(root, 4)
    insert_node(root, 5)
    print_node(root)

    s = Solution()
    head = s.reverseKGroup(root, 3)
    print_node(head)

3.2 Java编码实现

package LL03;


public class Main {
    //定义链表节点
    static class ListNode {
        private int val;  //链表的数值域
        private ListNode next; //链表的指针域

        public ListNode(int data) {
            this.val = data;
            this.next = null;
        }
    }

    //添加链表节点
    private static void insertNode(ListNode node, int data) {
        if (node == null) {
            return;
        }
        //创建一个新节点
        ListNode newNode = new ListNode(data);
        ListNode cur = node;
        //找到链表的末尾节点
        while (cur.next != null) {
            cur = cur.next;
        }
        //末尾节点的next指针域连接新节点
        cur.next = newNode;
    }

    //打印链表（从头节点开始打印链表的每一个节点）
    private static void printNode(ListNode node) {
        ListNode cur = node;
        //遍历每一个节点
        while (cur != null) {
            System.out.print(cur.val + "\t");
            cur = cur.next; //更改指针变量的指向
        }
        System.out.println();
    }


    public static class Solution {
        /**
         * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
         *
         * @param head ListNode类
         * @param k    int整型
         * @return ListNode类
         */
        public ListNode reverseKGroup(ListNode head, int k) {
            // write code here
            if (k <= 1) {
                return head;
            }
            // 1.获取链表长度，定义虚拟头结点、指针变量
            int linkLen = getListLen(head); //获取链表长度
            int groups = linkLen / k;//进行groups组翻转
            ListNode tmpHead = new ListNode(-1); //临时虚拟头节点
            ListNode now = tmpHead;

            // 2.进行groups组的反转
            // 2.1 定义每组连接节点反转的指针变量
            ListNode cur = head;//每组反转（操作的）当前节点
            ListNode nxt = head;//每组反转（操作的）下一个节点
            ListNode pre = null;//每组反转（操作的）前序节点
            for (int i = 0; i < groups; i++) {
                // 2.2 对每一组k个节点进行翻转进行翻转
                for (int j = 0; j < k; j++) {
                    nxt = cur.next;
                    cur.next = pre;
                    pre = cur;
                    cur = nxt;
                }
                //2.3 翻转之后，进行衔接
                now.next = pre; //如果i==0时（第一次翻转），tmpHead、now为同一个节点
                while (now.next != null) {
                    now = now.next;
                }
                // 2.4 每一组K个节点反转完成后，使反转（操作的）前序节点指向空(Null)
                pre = null;
            }
            //3. 衔接剩余的节点
            now.next = cur;

            return tmpHead.next;
        }

        private int getListLen(ListNode head) {
            //链表长度：链表节点数量
            int listLen = 0;
            ListNode cur = head;
            while (cur != null) {
                listLen++;
                cur = cur.next;
            }
            return listLen;
        }
    }

    public static void main(String[] args) {
        ListNode root = new ListNode(1);
        insertNode(root, 2);
        insertNode(root, 3);
        insertNode(root, 4);
        insertNode(root, 5);
        printNode(root);

        Solution solution = new Solution();
        ListNode head = solution.reverseKGroup(root, 3);
        printNode(head);
    }
}

3.3 Golang编码实现

package main

import "fmt"

// ListNode 定义链表节点
type ListNode struct {
    Val  int       //链表的数值域
    Next *ListNode //链表的指针域
}

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 *
 * @param head ListNode类
 * @param k int整型
 * @return ListNode类
 */
func reverseKGroup(head *ListNode, k int) *ListNode {
    // write code here
    if k <= 1 {
        return head
    }
    // 1.获取链表长度，定义虚拟头结点、指针变量
    listLen := getListLen(head)   //获取链表长度
    groups := listLen / k         //进行groups组翻转
    tmpHead := &ListNode{Val: -1} //临时虚拟头节点
    now := tmpHead

    // 2.进行groups组的反转
    // 2.1 定义每组连接节点反转的指针变量
    cur := head       //每组反转（操作的）当前节点
    nxt := head       //每组反转（操作的）下一个节点
    var pre *ListNode //每组反转（操作的）前序节点
    for i := 0; i < groups; i++ {
        // 2.2 对每一组k个节点进行翻转进行翻转
        for j := 0; j < k; j++ {
            nxt = cur.Next
            cur.Next = pre
            pre = cur
            cur = nxt
        }
        //2.3 翻转之后，进行衔接
        now.Next = pre
        for now.Next != nil {
            now = now.Next
        }
        // 2.4 每一组K个节点反转完成后，使反转（操作的）前序节点指向空(Null)
        pre = nil
    }
    //3. 衔接剩余的节点
    now.Next = cur
    return tmpHead.Next
}

func getListLen(head *ListNode) int {
    //链表长度：链表节点数量
    cur := head
    listLen := 0
    for cur != nil {
        listLen++
        cur = cur.Next
    }
    return listLen
}

func main() {
    root := &ListNode{
        Val:  1,
        Next: nil,
    }
    root.Insert(2)
    root.Insert(3)
    root.Insert(4)
    root.Insert(5)
    root.Print()

    head := reverseKGroup(root, 3)
    head.Print()

}

// Insert 从链表节点尾部添加节点
func (ln *ListNode) Insert(val int) {
    if ln == nil {
        return
    }
    //创建一个新节点
    newNode := &ListNode{Val: val}
    cur := ln
    //找到链表的末尾节点
    for cur.Next != nil {
        cur = cur.Next
    }
    //末尾节点的next指针域连接新节点
    cur.Next = newNode
}

// Print 从链表头结点开始打印链表的值
func (ln *ListNode) Print() {
    if ln == nil {
        return
    }
    cur := ln
    //遍历每一个节点
    for cur != nil {
        fmt.Print(cur.Val, "\t")
        cur = cur.Next //更改指针变量的指向
    }
    fmt.Println()
}

如果上面的代码理解的不是很清楚，你可以参考视频的详细讲解。

• Python版本：https://www.bilibili.com/cheese/play/ep1370259
• Java版本：https://www.bilibili.com/cheese/play/ep1366715
• Golang版本：https://www.bilibili.com/cheese/play/ep1364392

4.小结

链表K个一组进行翻转，可以通过3步完成。第一步：获取链表长度；第二步：进行groups组的反转；第三步：衔接剩余的节点。难点是对一组反转之后的链表节点如何连接，即在操作链表节点时指针变量的定义、移动。

更多算法视频讲解，你可以从以下地址找到：

• Python编码实现：https://www.bilibili.com/cheese/play/ep1509965
• Java编码实现：https://www.bilibili.com/cheese/play/ep1510007
• Golang编码实现：https://www.bilibili.com/cheese/play/ep1509945

对于链表的相关操作，我们总结了一套【可视化+图解】方法，依据此方法来解决链表相关问题，链表操作变得易于理解，写出来的代码可读性高也不容易出错。具体也可以参考视频详细讲解。

今日佳句：忽如一夜春风来，千树万树梨花开。