LeetCode 128 Reverse Nodes in k-Group

最新推荐文章于 2025-05-21 19:43:17 发布

原创最新推荐文章于 2025-05-21 19:43:17 发布 · 675 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode #Reverse Nodes in k-G #链表翻转

LeetCode 专栏收录该内容

151 篇文章

订阅专栏

本文介绍了一种链表操作方法，即每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

分析：

每k个节点旋转一次，后面剩余不足k个的节点不旋转。

链表操作时，新建一个dummy头节点是很有好处的。

一个pre节点指向需要旋转的链表前一个节点，往后数k，next指向需要旋转地链表后一个节点，则中间的一部分就是常规的链表翻转操作。

/**
 * 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 || k==1)
            return head;
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode pre = dummy;//指向当前要翻转链表的前一个节点
        
        int i=0;
        while(head != null){
            i++;
            if(i%k == 0){//到了k的倍数
                pre = reverse(pre, head.next);
                head = pre.next;
            }else
                head = head.next;
        }
        return dummy.next;
    }
    //pre指向翻转链表之前一个节点，next指向翻转链表之后一个节点
    public ListNode reverse(ListNode pre, ListNode next){
        ListNode last = pre.next;
        ListNode curr = last.next;
        while(curr != next){
            last.next = curr.next;
            curr.next = pre.next;
            pre.next = curr;
            curr = last.next;
        }
        return last;//指向当前链表尾，即下一个链表头节点的前一个节点
    }
}