leetcode-25 K 个一组翻转链表

笨笨小菜

已于 2022-03-02 17:02:52 修改

阅读量99

点赞数

分类专栏： leetcode 文章标签： leetcode 算法职场和发展

于 2021-02-08 15:53:15 首次发布

本文链接：https://blog.csdn.net/shushi6969/article/details/113758170

版权

leetcode 专栏收录该内容

210 篇文章 0 订阅

订阅专栏

本文详细介绍了如何通过分块反转的方法来处理链表问题，包括两个核心函数`reverseGroup`和`reverseKGroup`，分别用于反转指定大小的链表块。算法的时间复杂度为O(n)，空间复杂度为O(1)。通过实例展示了如何在链表中反转连续的k个节点，对于k小于等于1或者空链表的情况也进行了处理。

摘要由CSDN通过智能技术生成

力扣

思路：分块转换，最后一块不转换

//多维矩阵反转
ListNode* reverseGroup(ListNode* head, int k) {
    ListNode *res = new ListNode();
    ListNode *resHead;
    resHead = res;
    int i = 1;
    while(head) {
        ListNode *temp = res->next;
        ListNode *temp2 = head->next;
        res->next = head;
        head->next = temp;
        head = temp2;
        if (i % k == 0) {
            while(res->next) {
                res = res->next;
            }
        }
        i += 1;
    }
    return resHead->next;
}

ListNode* reverseKGroup(ListNode* head, int k) {
    if (k <= 1 || head == NULL) {
        return head;
    }

    ListNode *res = new ListNode();
    ListNode *resHead;
    resHead = res;
    ListNode *kgroup = new ListNode();
    ListNode *khead = kgroup;
    int i = 1;
    while(head) {
        ListNode *temp2 = head->next;
        kgroup->next = head;
        head->next = NULL;
        kgroup = kgroup->next;
        head = temp2;

        if (i % k == 0) {
            ListNode *temp = reverseGroup(khead->next, k);
            res->next = temp;
            res = res->next;
            while(res->next) {
                res = res->next;
            }
            kgroup = new ListNode();
            khead = kgroup;
        }
        i += 1;
    }
    res->next = khead->next;
    return resHead->next;
}

o(n), o(1)算法

class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* reverse(ListNode* head, ListNode* tail) {
        ListNode* res;
        ListNode* root = new ListNode(0);
        res = root;
        while (head != tail) {
            ListNode* temp = head->next;
            head->next = root->next;
            root->next = head;
            
            head = temp;
        }
        return res->next;
    }
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* root;
        ListNode* merge = new ListNode(0);
        root = merge;
        ListNode* tempHead = head;
        for (int i = 0; i < k; i++) {
            if (head) {
                head = head->next;
            } else {
                return tempHead;
            }
        }
        ListNode* newHed = reverse(tempHead, head);
        tempHead->next = reverseKGroup(head, k);
        //return newHed;
        return newHed;
    }
};