算法：将单链表的每K个节点之间逆序

题目描述

给定一个单链表，实现一个调整单链表的函数，使得每k个节点之间逆序，如果最后不够k个节点，不做调整。如：
1->2->3->4->5->6->7->8, k = 3
3->2->1->6->5->4->7->8

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* reverseKNode(ListNode* head, int k) {
        
    }
};

题目解析

• 如果k == 1，表示每1个节点为1组进行逆序，原链表不变

利用栈

思路：

1. 从左到右遍历链表，如果栈的大小不等于K，就将节点不断压入栈中
2. 当栈的大小第一个到达K时，说明第一次凑齐了K个节点进行逆序，从栈中依次弹出这些节点，并根据弹出的顺序重新连接。这一组逆序完成后，需要重新记录一下新的头部，同时第一组的最后一个节点应该连接下一个节点
   • 比如：链表1->2->3->4->5->6->7->8->null，k=3。
   • 第一组节点入栈，从栈顶到栈底依次为3,2，1.逆序后重连为3->2->1->…，然后节点1去连接节点4，链表变为3->2->1->4->5->6->7->8->null，之后从节点4开始不断处理K个节点为一组的后序情况，也就是步骤3，并且需要记录节点3，因为链表的头部已经改变，整个过程结束之后需要返回这个新的头结点，记为newHead
3. 步骤2之后，当栈的大小每次到达K时，说明又凑齐了K个节点进行逆序，从栈中依次弹出这些节点，并根据弹出的顺序重新连接。这一组逆序完成后，该组的第一个节点应该被上一组的最后一个节点连接上，这一组的最后一个节点应该去连接下一个节点。然后继续回到步骤3，直到所有链表都被遍历完
   • 比如：3->2->1->4->5->6->7->8->null，K=3，第一组已经处理完成。第二组从栈顶到栈底依次为6,5，4，逆序重连后为6->5->4，然后节点6应该被节点1连接，节点4应该连接节点7，链表变为3->2->1->6->5->4->7->8->null。
   • 然后继续从节点7开始往下遍历

• 最后返回newHead，作为链表新头结点

class Solution {
    ListNode *resign(std::stack<ListNode*>& stack, ListNode*left, ListNode*right){
        ListNode *curr = stack.top(); stack.pop();
        if(left != nullptr){
            left->next = curr;
        }
        ListNode *next = nullptr;
        while (!stack.empty()){
            next = stack.top(); stack.pop();
            curr->next = next;
            curr = next;
        }
        curr->next = right;
        return curr;
    }
public:
    ListNode* reverseKNode(ListNode* head, int k) {
        if(k < 2){
            return head;
        }
        
        std::stack<ListNode*> stack;
        ListNode *newHead = head;
        ListNode *prev = nullptr, *curr = head, *next = nullptr;
        while (curr != nullptr){
            next = curr->next;
            stack.push(curr);
            if(stack.size() == k){
                prev = resign(stack, prev, next);
                newHead = newHead == head ? curr : newHead;
            }
            curr = next;
        }
        return newHead;
    }
};

时间复杂度为O(N)，空间复杂度为O(K)

就地反转

class Solution {
    ListNode *resign( ListNode*left, ListNode*start, ListNode*end, ListNode*right){
        ListNode*prev = start, *curr = prev->next, *next = nullptr;
        while (curr != right){
            next = curr->next;
            curr->next = prev;
            prev = curr;
            curr = next;
        }
        if(left != nullptr){
            left->next = end;
        }
        start->next = right;
        return curr;
    }
public:
    ListNode* reverseKNode(ListNode* head, int k) {
        if(k < 2){
            return head;
        }
        

        int count = 1;
        ListNode *prev = nullptr, *start = nullptr, *curr = head, *next = nullptr;
        while (curr != nullptr){
            next = curr->next;
            if(count == k){
                start = prev == nullptr ? head : prev->next;
                head = prev == nullptr ? curr : head;
                resign(prev, start, curr, next);
                prev = start;
                count;
            }
            count++;
            curr = next;
        }
        return head;
    }
};