25. K 个一组翻转链表 C++ 2021-08-28

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:
    // 翻转一个子链表，并且返回新的头与尾
    pair<ListNode*, ListNode*> myReverse(ListNode* head, ListNode* tail) {
        ListNode* prev = tail->next;
        ListNode* cur = head;
        while (prev != tail) {
            ListNode* nex = cur->next;
            cur->next = prev;
            prev = cur;
            cur = nex;
        }
        return {tail, head};
    }

    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* hair = new ListNode(0);
        hair->next = head;
        ListNode* pre = hair;

        while (head) {
            ListNode* tail = pre;
            for (int i = 0; i < k; ++i) // 查看剩余部分长度是否大于等于 k
            {
                tail = tail->next;
                if (!tail) {
                    return hair->next;
                }
            }
            ListNode* nex = tail->next;
            // 这里是 C++17 的写法，也可以写成
            // pair<ListNode*, ListNode*> result = myReverse(head, tail);
            // head = result.first;
            // tail = result.second;
            tie(head, tail) = myReverse(head, tail);
            // 把子链表重新接回原链表
            pre->next = head;
            tail->next = nex;
            pre = tail;
            head = tail->next;
        }

        return hair->next;
    }
};

2、反转+递归

class Solution {
public:
    ListNode* myReverse(ListNode* a, ListNode* b) 
    {
        ListNode* pre = nullptr;
        ListNode* cur = a;
        ListNode* nex = a;
        while (cur != b) 
        {
            nex = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nex;
        }
        return pre;
    }

    ListNode* reverseKGroup(ListNode* head, int k) 
    {
        if (head == nullptr)
            return head;

        ListNode* a = head;
        ListNode* b = head;

        for (int i = 0; i < k; ++i) // 查看剩余部分长度是否大于等于 k
        {
            if (b == nullptr) 
                return head;
            b = b->next;
        }
        ListNode* newHead = myReverse(a, b);
        //递归
        a->next = reverseKGroup(b, k);
        return newHead;
    }
};