leetcode Reverse Nodes in k-Group

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

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

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

30 篇文章

订阅专栏

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

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        int len=0;
        ListNode *lencount=head;
        while(lencount!=NULL) {
            len++;
            lencount=lencount->next;
        }
        if(len<=1||k==1) return head;
        ListNode *result=head,*pre,*start=head,*next,*headTemp,*tailTemp;
        bool flag=false;
        while((len=len-k)>=0){
            if(!flag){
                next=sub(start,k,result,pre);
                flag=true;
            }
            else{
                start=next;
                next=sub(start,k,headTemp,tailTemp);
                pre->next=headTemp;
                pre=tailTemp;
            }
        }
        pre->next=next;
        return result;
    }
    ListNode* sub(ListNode *start,int k,ListNode *&head,ListNode *&tail){     //逆转start开头的K个node,并且保存逆转后的开头和结尾，并返回下一个node，以供连接
        ListNode *sting=new ListNode(INT_MIN),*pre,*cur,*next;
        int len=0;
        tail=start;
        sting->next=start;
        pre=sting;
        cur=start;
        while(len<k){
            next=cur->next;
            cur->next=pre;
            pre=cur;
            cur=next;
            len++;
        }
        head=pre;
        return next;
    }
};

开始的时候感觉遍历两边处理就不是很好，果然有巧妙的方法。如下方法，将pre加入到逆转，实现了连接功能

public ListNode reverseKGroup(ListNode head, int k) {  
    if(head == null)  
    {  
        return null;  
    }  
    ListNode dummy = new ListNode(0);  
    dummy.next = head;  
    int count = 0;  
    ListNode pre = dummy;  
    ListNode cur = head;  
    while(cur != null)  
    {  
        count ++;  
        ListNode next = cur.next;  
        if(count == k)  
        {  
            pre = reverse(pre, next);  
            count = 0;     
        }  
        cur = next;  
    }  
    return dummy.next;  
}  
private ListNode reverse(ListNode pre, ListNode end)  
{  
    if(pre==null || pre.next==null)  
        return pre;  
    ListNode head = pre.next;  
    ListNode cur = pre.next.next;  
    while(cur!=end)  
    {  
        ListNode next = cur.next;  
        cur.next = pre.next;  
        pre.next = cur;  
        cur = next;  
    }  
    head.next = end;  
    return head;  
}