25. Reverse Nodes in k-Group

最新推荐文章于 2025-08-14 20:57:38 发布

SnailRunFast

最新推荐文章于 2025-08-14 20:57:38 发布

阅读量212

点赞数

CC 4.0 BY-SA版权

分类专栏： Leet Code 文章标签： leetcode Reverse Nodes in k-G

本文链接：https://blog.youkuaiyun.com/snailrunfast/article/details/66472776

Leet Code 专栏收录该内容

143 篇文章

订阅专栏

本文介绍了一种在常数空间复杂度下反转链表中每K个节点的方法，并提供了详细的Java实现代码。该方法使用两个指针记录一组元素，在不改变节点值的情况下仅改变节点连接，以达到反转的效果。

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

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

k is a positive integer and is less than or equal to the length of the linked 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

Solution:

Tips:

Just use two pointers to record a group of elements.

Java Code :

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (null == head || k == 1) {
            return head;
        }
        
        ListNode newHead = new ListNode(0);
        ListNode groupTail = newHead; // record the last element of the group
        // pointer1 close to head
        ListNode h = head;
        // pointer2 k steps after h
        ListNode t = head;
        int n = k;
        // find a group of k elements
        while (t != null && n > 0) {
            t = t.next;
            n--;
        }
        // list has elements less than k
        if (n > 0) {
            return head;
        }
        
        while (h != null && n == 0) {
            n = k;
            ListNode gt = h;
            // reverse group elements
            while (n > 0) {
                ListNode p = h;
                h = h.next;
                
                p.next = groupTail.next;
                groupTail.next = p;
                n--;
            }
            
            // forward k steps
            n = k;
            while (t != null && n > 0) {
                t = t.next;
                n--;
            }
            
            groupTail = gt;
        }
        
        if (n > 0) {
            groupTail.next = h;
        }
        
        return newHead.next;
    }
}