[LintCode] Reverse Nodes in k-Group 每k个一组翻转链表

最新推荐文章于 2025-09-10 15:24:29 发布

转载最新推荐文章于 2025-09-10 15:24:29 发布 · 46 阅读

文章标签：

#数据结构与算法

本文介绍了一种算法问题的解决方法：给定一个链表，按k个一组翻转链表节点，并返回修改后的链表。若链表节点数不是k的倍数，则剩余节点保持原样。解决方案需在常数空间复杂度下实现，不改变节点值，只改变节点指向。

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.
Only constant memory is allowed.

Have you met this question in a real interview?

Yes

Example

Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5

LeetCode上的原题，请参见我之前的博客Reverse Nodes in k-Group 每k个一组翻转链表。

解法一：

class Solution {
public:
    /**
     * @param head a ListNode
     * @param k an integer
     * @return a ListNode
     */
    ListNode *reverseKGroup(ListNode *head, int k) {
        ListNode *dummy = new ListNode(-1), *pre = dummy, *cur = pre;
        dummy->next = head;
        while (cur->next) {
            int d = k;
            while (cur->next && d-- > 0) {
                cur = cur->next;
            }
            if (d > 0) return dummy->next;
            ListNode *t = cur->next;
            cur->next = NULL;
            pre->next = reverse(pre->next);
            for (int i = 0; i < k; ++i) pre = pre->next;
            pre->next = t;
            cur = pre;
        }
        return dummy->next;
    }
    ListNode* reverse(ListNode *head) {
        ListNode *dummy = new ListNode(-1), *cur = head;
        dummy->next = head;
        while (cur && cur->next) {
            ListNode *t = cur->next;
            cur->next = t->next;
            t->next = dummy->next;
            dummy->next = t;
        }
        return dummy->next;
    }
};

解法二：

class Solution {
public:
    /**
     * @param head a ListNode
     * @param k an integer
     * @return a ListNode
     */
    ListNode *reverseKGroup(ListNode *head, int k) {
        ListNode *dummy = new ListNode(-1), *pre = dummy, *cur = pre;
        dummy->next = head;
        int num = 0;
        while (cur = cur->next) ++num;
        while (num >= k) {
            cur = pre->next;
            for (int i = 1; i < k; ++i) {
                ListNode *t = cur->next;
                cur->next = t->next;
                t->next = pre->next;
                pre->next = t;
            }
            pre = cur;
            num -= k;
        }
        return dummy->next;
    }
};

解法三：

class Solution {
public:
    /**
     * @param head a ListNode
     * @param k an integer
     * @return a ListNode
     */
    ListNode *reverseKGroup(ListNode *head, int k) {
        ListNode *cur = head;
        for (int i = 0; i < k; ++i) {
            if (!cur) return head;
            cur = cur->next;
        }
        ListNode *new_head = reverse(head, cur);
        head->next = reverseKGroup(cur, k);
        return new_head;
    }
    ListNode* reverse(ListNode* head, ListNode* tail) {
        ListNode *pre = tail;
        while (head != tail) {
            ListNode *t = head->next;
            head->next = pre;
            pre = head;
            head = t;
        }
        return pre;
    }
};