LeetCode 25. K 个一组翻转链表

难度：困难。
比较绕，得想清楚。

1. 找到当前k个数中的最后一个，即代码中的end_k_node，如果这个节点存在，则继续下面的替换；否则结束。
2. 每次将当前的K组节点的第一个节点放到end_k_node的后面，直到第一个节点为end_k_node为止。
3. 继续对下一个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:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(k <= 1||!head||!head->next)return head;
        ListNode* node = head, *ans = head;
        int flag = 0;
        while(node->next){
            ListNode *end_k_node = node->next;
            if(flag == 0){
                end_k_node = node;
            }
            int p = 0;
            for(int i = 0; i < k - 1; i++){
                if(!end_k_node->next){
                    p = 1;
                    break;
                }
                end_k_node = end_k_node->next;
            }
            if(p)break;

            ListNode* temp_node = node->next;
            if(flag == 0){
                temp_node = node;
                ans = end_k_node;
                flag = 1;
            }
            else{
                node->next = end_k_node;
            }
            node = temp_node;
            for(int i = 0; i < k - 1; i++){
                ListNode *n = temp_node->next;
                temp_node->next = end_k_node->next;
                end_k_node->next = temp_node;
                temp_node = n;
            }
        }
        return ans;
    }
};

2021.7.21 二刷

先对链表数量进行计数，再根据个数进行反转。

正确解法：

/**
 * 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:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(head == nullptr || k == 1)return head;
        int num = 0;
        ListNode* cur = head;
        while(cur != nullptr){
            num++;
            cur = cur->next;
        }
        cur = head;
        ListNode* lastGroup = nullptr;
        ListNode* ans = nullptr;
        for(int i = 0; i < num / k; ++i){
            ListNode* nextNode = cur->next;
            ListNode* startNode = cur;
            for(int j = 0; j < k - 1; ++j){
                ListNode* temp = nextNode->next;
                nextNode->next = cur;
                cur = nextNode;
                nextNode = temp;
            }
            if(i == 0)ans = cur;
            if(lastGroup != nullptr)lastGroup->next = cur;
            startNode->next = nextNode;
            lastGroup = startNode;
            cur = nextNode;
        }
        return ans;
    }
};

结果：