61. Rotate List(旋转链表)
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;
}
};