K个一组翻转链表-链表25-c++

算法思想：

• 链表分区为已翻转部分+待翻转部分+未翻转部分
• 每次翻转前，要确定翻转链表的范围，这个必须通过 k 此循环来确定
• 需记录翻转链表前驱和后继，方便翻转完成后把已翻转部分和未翻转部分连接起来
• 初始需要两个变量 pre 和 end，pre 代表待翻转链表的前驱，end 代表待翻转链表的末尾
• 经过k此循环，end 到达末尾，记录待翻转链表的后继 next = end.next
• 翻转链表，然后将三部分链表连接起来，然后重置 pre 和 end 指针，然后进入下一次循环
• 特殊情况，当翻转部分长度不足 k 时，在定位 end 完成后，end==null，已经到达末尾，说明题目已完成，直接返回即可
• 时间复杂度为 O(n*K)最好的情况为 O(n)最差的情况未 O(n^2)
• 空间复杂度为 O(1)除了几个必须的节点指针外，我们并没有占用其他空间
  
  

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* reverse(ListNode* head){
        ListNode* pre = nullptr;
        ListNode* curr = head;
        ListNode* temp;
        while(curr){
            temp = curr;
            curr = curr->next;
            temp->next = pre;
            pre = temp;
        }
        return pre;
    }
    
    ListNode* reverseKGroup(ListNode* head, int k) {
        // write code here
        ListNode* dummy = new ListNode(100);
        dummy->next = head;
        ListNode* pre = dummy;
        ListNode* end = pre;
        while(end->next != nullptr){
            for(int i = 0;i < k; ++i){
                end = end->next;
                if(!end) return dummy->next;
            }
            ListNode* start = pre->next;
            ListNode* next = end->next;
            end->next = nullptr;
            pre->next = reverse(start);
            start->next = next;
            pre = start;
            end = pre;
        }
        return dummy->next;
        
    }
};

/**
 * 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) {
        // 递归思想实现k个一组翻转后，再接着翻转下一组
        ListNode* a = head, *b = head;
        for (int i = 0; i < k; i++) {
            if (b == nullptr) return head;
            b = b->next;
        }

        ListNode* newHead = reverse(a, b); // 组内翻转
        a->next = reverseKGroup(b, k); // 翻转后，与下一翻转后的组的开头连接
        return newHead; // 对于最外层递归，newHead就是最终答案
    }

    ListNode* reverse(ListNode* a, ListNode* b) {
        // 局部翻转链表，参考反转整个链表的思想
        // 就是由nullptr换成了ListNode* b
        ListNode* dummy = new ListNode(-1);
        ListNode* pre = dummy;
        ListNode* curr = a;
        ListNode* tmp = curr;

        while (curr != b) {
            curr = curr->next;
            tmp->next = pre;
            pre = tmp;
            tmp = curr;
        }

        return pre;
    }
};