61. Rotate List（旋转链表）三种解法（C++ & 注释）

1. 题目描述

给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。

示例 1:

输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL

示例 2:

输入: 0->1->2->NULL, k = 4
输出: 2->0->1->NULL
解释:
向右旋转 1 步: 2->0->1->NULL
向右旋转 2 步: 1->2->0->NULL
向右旋转 3 步: 0->1->2->NULL
向右旋转 4 步: 2->0->1->NULL

题目链接：中文题目；英文题目

2. 暴力解法（Brute Force）

2.1 解题思路

这题是189. 旋转数组的链表版，所以我们可以使用上题的方法来解决这道题。首先我们想到的就是暴力求解了：每旋转一次则所有的数向右移动一位。并且通过观察可以发现，当0 < k < 链表长度(len)时，这些情况的结果包括了后面所有k的情况，所以我们只需旋转 k % len次即可。

2.2 实例代码

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if (!head) return nullptr;
        int len = 0;
        ListNode* node = head;
        while (node) { len++; node = node->next; }

        k %= len;
        node = head;
        int temp = node->val;
        for (int i = 0; i < k; i++) {
            while (node->next) {
                int transfer = node->next->val;
                node->next->val = temp;
                temp = transfer;
                node = node->next;
            }

            head->val = temp; // 最后一个的值赋值给第一个
            node = head;
        }

        return head;
    }
};

3. 周期替换（Using Cyclic Replacements）

3.1 解题思路

既然旋转有周期变化的规律，那么我们来观察一下一个周期之内，序号(idx)的变化规律（k %= len）：

通过观察上图的例子，我们发现idx变化到(idx + k) % len的位置，回到起点序号时该轮遍历结束，而且需要遍历到所有的节点，所以我们用count来进行计数，如果count = len，则停止遍历；反之，则进行下一轮遍历。

3.2 实例代码

3.2.1 使用额外空间 - 数组

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if (!head) return nullptr;
        ListNode* node = head;
        vector<int> nums;
        while (node) { nums.push_back(node->val); node = node->next; } // 将链表转换成数组来操作

        int count = 0;
        k %= nums.size();
        for (int start = 0; count < nums.size(); start++) {
            int current = start;
            int pre = nums[current];
            do {
                int next = (current + k) % nums.size();
                int temp = nums[next];
                nums[next] = pre;
                pre = temp;
                current = next;
                count++;
            } while (start != current);
        }

        node = head;
        for (int i = 0; i < nums.size(); i++) { node->val = nums[i]; node = node->next; }
        return head;
    }
};

3.2.2 不适用额外空间

class Solution {
    int getValue(ListNode* head, int current) {
        for (int i = 0; i < current; i++) head = head->next;
        return head->val;
    }

    ListNode* getNode(ListNode* head, int current) {
        for (int i = 0; i < current; i++) head = head->next;
        return head;
    }

public:
    ListNode* rotateRight(ListNode* head, int k) {
        if (!head) return nullptr;
        ListNode* node = head;
        int len = 0;
        while (node) { len++; node = node->next; }

        int count = 0;
        k %= len;
        for (int start = 0; count < len; start++) {
            int current = start;
            int pre = getValue(head, current);
            do {
                int next = (current + k) % len;
                int temp = getValue(head, next);
                getNode(head, next)->val = pre;
                pre = temp;
                current = next;
                count++;
            } while (start != current);
        }

        return head;
    }
};

4. 翻转（Using Reverse）

4.1 解题思路

首先，我们发现一个周期内，向右移动k位，后面k个节点被移动到了最前面，原来前面len - k个节点被顺势移动到了最后面。所以先翻转整个数组，后面的节点移动到了前面，前面的节点被移动到了后面，但是这两部分的节点是倒序的，所以我们只需对这两个部分再分别翻转一次，即可得到原来的结果，比如：

1->2->3->4, k = 2
翻转整个链表：4->3->2->1
翻转前k个节点：3->4->2->1
翻转后k - 1个节点：3->4->1->2

4.2 实例代码

class Solution {
    void reverseLinkedList(ListNode* head, int start, int end) {
        while (start < end) {
            int temp = getValue(head, start);
            getNode(head, start)->val = getValue(head, end);
            getNode(head, end)->val = temp;
            start++;
            end--;
        }
    }

    int getValue(ListNode* head, int current) {
        for (int i = 0; i < current; i++) head = head->next;
        return head->val;
    }

    ListNode* getNode(ListNode* head, int current) {
        for (int i = 0; i < current; i++) head = head->next;
        return head;
    }

public:
    ListNode* rotateRight(ListNode* head, int k) {
        if (!head) return nullptr;
        ListNode* node = head;
        int len = 0;
        while (node) { len++; node = node->next; }

        k %= len;
        reverseLinkedList(head, 0, len - 1);
        reverseLinkedList(head, 0, k - 1);
        reverseLinkedList(head, k, len - 1);
        return head;
    }
};

5. 参考资料

1. 189. Rotate Array

---