Leetcode:给定一个链表，每次反转链表k的节点并返回其修改后的链表。如果节点的数量不是k的倍数，那么最后遗漏的节点应该保持原样。

最新推荐文章于 2021-04-22 14:56:48 发布

原创最新推荐文章于 2021-04-22 14:56:48 发布 · 327 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#Leetcode #Java #链表

本文介绍了一种算法，用于将链表的节点每K个一组进行反转，同时保持末尾不足K个节点的顺序不变。通过设置预节点和当前节点，利用循环对链表进行分段反转，最终返回修改后的链表头。此算法适用于链表处理和数据结构学习。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.

Only constant memory is allowed.

For example,
Given this linked list:1->2->3->4->5

For k = 2, you should return:2->1->4->3->5

For k = 3, you should return:3->2->1->4->5

思路：设置变量len，头指针head一直往后移动，len++，最后得到整条链表的长度。然后把链表分成k个部分，然后对这k个部分都进行链表反转操作，返回新的头指针，即可得到结果。

Java代码实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(head == null || head.next == null || k < 2)
            return head;
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode pre,cur,tmp;
        pre = dummy;
        cur = head;
        int len = 0;
        while(head != null){
            head = head.next;
            len++;
        }
        for(int i = 0;i < len / k;i++){
            for(int j = 1;j < k;j++){
                tmp = cur.next;
                cur.next = tmp.next;
                tmp.next = pre.next;
                pre.next = tmp;
            }
            pre = cur;
            cur = cur.next;
        }
        return dummy.next;
    }
}