前一段时间一直在搞论文和入职，算法题放下了。今天开始重新拾起来，一道题复健

leetcode 25 K个一组反转链表

没啥好说的，就模拟。但确实比较练基本功，适合复健。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */

class Solution {
public:
    void reverse(ListNode* start_prev, ListNode* end){ // (start_prev, end]
        if(start_prev->next == end) return;
        ListNode* p_prev = start_prev;
        ListNode* p = start_prev->next;
        ListNode* q = start_prev->next->next;
        while(q != end->next){
            p->next = p_prev;
            p_prev = p;
            p = q;
            q = q->next;
        }
        p->next = p_prev;
        start_prev->next->next = q;
        start_prev->next = p;
    }
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(!head || !head->next || k == 1) return head;
        auto* dummy_head = new ListNode(0, head);
        ListNode* p_prev = dummy_head;
        ListNode* p = head;
        while(p){
            int tmp = k;
            ListNode* end = p_prev;
            while(tmp > 0 && end){
                end = end->next;
                --tmp;
            }
            if(tmp > 0 || !end) break;
            reverse(p_prev, end);
            p_prev = p;
            p = p->next;
        }
        return dummy_head->next;
    }
};

虚拟头节点确实很好用，避免了很多特判。做链表题一定要画图，靠脑子想大概率出问题甚至猪脑过载。