【链表转置】Reverse Nodes in k-Group

最新推荐文章于 2024-08-19 18:39:12 发布

原创最新推荐文章于 2024-08-19 18:39:12 发布 · 544 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

136 篇文章

订阅专栏

本文介绍了一种算法，该算法可以将链表每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.

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

解法：reverse将链表原地转置，使用一个新节点，将原先的链表元素插入到头结点之后

public class Solution {
    public ListNode reverse(ListNode head){
        ListNode p = head;
        ListNode pre = new ListNode(0);
        head = pre;
        
        while(p != null){
            ListNode r = p.next;
            p.next = head.next;
            head.next = p;
            
            p = r;
        }
        pre = pre.next;
        head.next = null;
        return pre;
    }
    
    public ListNode reverseKGroup(ListNode head, int k) {//k个元素判断一次
        ListNode p1 = head;
        if(k<=1 || head == null) return head;
        
        int count = 0;
        ListNode pre = null;
        while(p1 != null && count < k){
            count++;
            pre = p1;
            p1 = p1.next;
        }
        if(count < k) return head;
        
        pre.next = null;
        pre = reverse(head);//head转置后变为新链表的最后一个节点，返回新链表的头结点
        
        head.next = reverseKGroup(p1, k);
        return pre;
    }
}