面试经典 150 题 6 —（链表）— 25. K 个一组翻转链表

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:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        // 使用虚拟头节点避免头节点变化的分类讨论
        ListNode *dummyNode = new ListNode(-1);
        dummyNode->next = head;

        ListNode *pre = dummyNode;
        //1. 从虚拟头节点走left-1步， 来到left节点的前一个节点，也就是待反转子链表的前驱
        for(int i = 0; i < left - 1; i++){
            pre = pre->next;
        }
        //2.从pre再走right-left+1步，来到right节点，rightNode节点就是待反转子链表的末尾节点
        ListNode *rightNode = pre;
        for(int i = 0; i < right - left + 1; i++){
            rightNode = rightNode->next;
        }
        //3.切断出一个子链表
        // leftNode节点就是待反转子链表的开始节点
        ListNode *leftNode = pre->next;
        // succ是待反转子链表的后继节点
        ListNode *succ = rightNode->next;
        // 把待反转子链表切割出来
        pre->next = nullptr;
        rightNode->next = nullptr;
        //4.反转链表的子区间；用头插法
        ListNode *tempDummy = new ListNode(-1);
        ListNode *tempCur = leftNode;
        while(tempCur){
            ListNode *nextHead = tempCur->next;
            tempCur->next = tempDummy->next;
            tempDummy->next = tempCur;
            tempCur = nextHead;
        }
        //5.接回到原来的链表中，所有之前需要记录待反转子链表的前驱和后继
        pre->next = rightNode;
        leftNode->next = succ;
        return dummyNode->next;
	}
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode *num = head;
        int length = 0;
        while(num){
            length++;
            num = num->next;
        }
        ListNode *res = head;
        for(int i = 1; i*k <= length; i++){
            res = reverseBetween(res, i*k-k+1 , i*k);
        }
        return res;
    }
};

/**
 * 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* reverseBetween(ListNode* head, int left, int right) {
        // 使用虚拟头节点避免头节点变化的分类讨论
        ListNode *dummyNode = new ListNode(-1);
        dummyNode->next = head;

        ListNode *pre = dummyNode;
        //1. 从虚拟头节点走left-1步， 来到left节点的前一个节点，也就是待反转子链表的前驱
        for(int i = 0; i < left - 1; i++){
            pre = pre->next;
        }
        //2.从pre再走right-left+1步，来到right节点，rightNode节点就是待反转子链表的末尾节点
        ListNode *rightNode = pre;
        for(int i = 0; i < right - left + 1; i++){
            rightNode = rightNode->next;
        }
        //3.切断出一个子链表
        // leftNode节点就是待反转子链表的开始节点
        ListNode *leftNode = pre->next;
        // succ是待反转子链表的后继节点
        ListNode *succ = rightNode->next;
        // 把待反转子链表切割出来
        pre->next = nullptr;
        rightNode->next = nullptr;
        //4.反转链表的子区间；直接改变节点指针的指向
        ListNode *tempPre = nullptr; // 便于第一个节点的next指针改变指向
        ListNode *tempCur = leftNode;
        while(tempCur){
        	// 记录下一个节点，确保tempCur的指针指向改变之后仍然能够找到原链表中tempCur的下一个节点
            ListNode *next = tempCur->next;
            // 当前的节点指向前一个节点，达到反转的效果
            tempCur->next = tempPre;
            // 两个指针都往后挪一个
            tempPre = tempCur;
            tempCur = next;
        }
        //5.接回到原来的链表中，所有之前需要记录待反转子链表的前驱和后继
        pre->next = rightNode;
        leftNode->next = succ;
        return dummyNode->next;
	}
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode *num = head;
        int length = 0;
        while(num){
            length++;
            num = num->next;
        }
        ListNode *res = head;
        for(int i = 1; i*k <= length; i++){
            res = reverseBetween(res, i*k-k+1 , i*k);
        }
        return res;
    }
};

方法二

/**
 * 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:
    // 翻转一个子链表，直接改变next指针的指向
    ListNode *reverse(ListNode* head){
        // 创建一个空的头节点，便于第一个节点next指针指向的改变
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while(cur){
            // 记录下一个节点，确保cur指向改变之后仍然能够找到原链表中cur的下一个节点
            ListNode* nextNode = cur->next;
            // 当前的节点指向前一个节点，达到反转的效果
            cur->next = pre;
            // pre和cur都往后挪一个
            pre = cur;
            cur = nextNode;
        }
        return pre;
    }
    ListNode* reverseKGroup(ListNode* head, int k) {
        // 创建虚拟头节点
        ListNode* dummy = new ListNode(-1);
        dummy->next = head;
        // 1.找待反转子链表的前驱pre、后继succ以及待反转子链表的第一个节点start和最后一个节点end，并且把待反转的子链表通过end->next=nullptr的方式从原链表中切下，进行反转，最后再把反转好的子链表接到原链表中
        // 待反转子链表的前驱节点
        ListNode* pre = dummy;
        // 待反转子链表的第一个节点
        ListNode* start = pre->next;
        // 待反转子链表的最后一个节点
        ListNode* end = dummy;
        while(end->next){
            // 找待反转子链表的最后一个节点
            for(int i = 0; i < k && end; i++){
                end = end->next;
            }
            if(!end){
                break;
            }
            // 待反转子链表的后继节点
            ListNode* succ = end->next;
            // 把待反转的子链表从原链表中切断
            end->next = nullptr;
            // 前驱节点的下一个节点就是待反转子链表反转之后的第一个节点
            pre->next = reverse(start);
            // 反转之后start就成了反转链表的最后一个节点，将反转之后的最后一个节点链接到前一轮记录的后继节点上
            start->next = succ;
            // 2.调整新一轮的待反转子链表的前驱pre以及待反转子链表的第一个节点start和最后一个节点end
            // 调整新一轮的前驱节点，指向待反转链表反转之后的最后一个节点，也就是反转之前的start
            pre = start;
            // 调整新一轮的后继节点，指向待反转链表反转之后的最后一个节点，也就是反转之前的start
            start = succ;
            // 调整新一轮待反转链表的最后一个节点
            end = pre;
        }
        return dummy->next;
    }
};