【一天一道LeetCode】#25. Reverse Nodes in k-Group_linkedlist 0-k k-2k 反转-优快云博客

本文链接：https://blog.youkuaiyun.com/terence1212/article/details/51226710

本文介绍了一道LeetCode上的经典链表题目——K个一组翻转链表的解决方案。该算法通过以K为单位翻转链表中的节点，并确保除了K的倍数节点外其余节点保持原有顺序，同时只使用常量级内存实现。

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

一天一道LeetCode系列

（一）题目

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) {
        //主要思想：以K为间距，分别对间距内的链表进行反转
        //需要注意的问题：为了防止链表断裂需要记录每一段的首尾元素
        ListNode* pret = head;
        ListNode* phead = head;//当前待反转的head节点
        ListNode* ptail = NULL;//当前待反转的尾节点
        ListNode* pnexthead = NULL;.//记录下一段的head
        ListNode* plasttail = NULL;//记录前一段的尾节点
        if(head == NULL) return NULL;
        while(phead!=NULL)
        {
            int gap=k;
            ListNode* p = phead;
            while(gap != 1&& p!=NULL) {p = p->next;gap--;}//找到尾节点
            if(p!=NULL){
                ptail = p;
                ListNode* tmp;
                pnexthead = p->next;
                if(phead == head) pret = reverseK(phead,ptail,pnexthead);//0-k段的时候要记录整个链表的头节点
                else 
                {
                    tmp = reverseK(phead,ptail,pnexthead);
                    plasttail->next = tmp;
                }
                phead = pnexthead;//跳转到下一段
                plasttail = ptail;//记录当前段的尾节点
            }
            else 
            {
                if(plasttail!= NULL) plasttail->next = phead;//将[0-k]，[k+1-2k]......链接起来，防止链表断裂
                phead = NULL;//如果链接最后凑不够K个元素，则将phead置为NULL
            }
        }
        return pret;
    }
    ListNode* reverseK(ListNode* phead ,ListNode* &ptail/*注意此处用引用来获得尾节点*/,ListNode* pnexthead)
    {
        ListNode* prevHead = phead;
        ListNode* p = phead->next;
        ListNode* pre = phead;
        while(1)
        {
            if(p==pnexthead) {
               ptail = pre;//返回尾节点
               return prevHead; 
            }
            pre->next = p->next;
            p->next = prevHead;
            prevHead = p;
            p=pre->next;
        }
    }
};