25. K 个一组翻转链表——难点和重点

题目

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

进阶：

你可以设计一个只使用常数额外空间的算法来解决此问题吗？
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

示例 2：

输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]

示例 3：
输入：head = [1,2,3,4,5], k = 1
输出：[1,2,3,4,5]

示例 4：
输入：head = [1], k = 1
输出：[1]

提示：
列表中节点的数量在范围 sz 内
1 <= sz <= 5000
0 <= Node.val <= 1000
1 <= k <= sz

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解

https://labuladong.github.io/algo/2/17/18/
链接中的讲解非常好

k个一组反转反转链表：

第一步将链表进行分解，每k个节点作为一个部分，[a，b)中左闭右开，包含k个节点。
第二步进行反转，将k个节点的链表进行反转。因为知道开始和结束节点，可以使用while循环进行简单的反转。
第三步定义合适的返回值，将k个节点进行链接。

难点

1. 将k个节点的链表进行反转，返回值的处理比较难以思考。
2. 特殊情况的处理
   例如：
   1. 1，1
   2. [1, 2], 2

解答

/**
 * 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* reverseN(ListNode* head, ListNode* end) {
        ListNode* pre, *cur, *nxt;
        pre = nullptr, cur=head, nxt=head;
        while(cur!=end)
        {
            nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }

    ListNode* reverseKGroup(ListNode* head, int k) {
        if (head == nullptr)
        {
            return nullptr;
        }
        ListNode * left=head, *right=head;
        for(int i=0;i<k;i++)
        {
            if(right!=nullptr)
            {
                right = right->next;
            }
            else
            {
                return head;
            }
        }
        ListNode* newhead = reverseN(head, right);
        head->next =  reverseKGroup(right, k);


        return newhead;

    }
};