给你链表的头节点
head
,每k
个节点一组进行翻转,请你返回修改后的链表。
k
是一个正整数,它的值小于或等于链表的长度。如果节点总数不是k
的整数倍,那么请将最后剩余的节点保持原有顺序。你不能只是单纯的改变节点内部的值,而是需要实际进行节点交换。
示例 1:
输入:head = [1,2,3,4,5], k = 2 输出:[2,1,4,3,5]示例 2:
输入:head = [1,2,3,4,5], k = 3 输出:[3,2,1,4,5]提示:
- 链表中的节点数目为
n
1 <= k <= n <= 5000
0 <= Node.val <= 1000
进阶:你可以设计一个只用
O(1)
额外内存空间的算法解决此问题吗?
这道题写了很久,感觉确实是O(1)空间复杂度,但是占内存击败5%,时间3ms击败99%,不过重复提交,击败的%是不一样的,代码写的感觉还是又臭又长。
链表还是要设置抽出来的节点node->next = NULL, 这次写代码的时候链表形成环,死循环了。找了很久问题,但是早加上这一步就能及时排查错误了。
思路就是原地逆序,不够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:
ListNode* reverseKGroup(ListNode* head, int k) {
if (head == NULL || k == 1) return head;
ListNode* res = new ListNode();
res->next = head;
ListNode* cur = res;
int flag = 0;
while (cur->next != NULL) {
ListNode* n1 = new ListNode();
ListNode* nk = new ListNode();
ListNode* temp;
for (int i = 0; i < k; i++) {
if (cur->next == NULL) {
flag = 1;
break;
}
if (i == 0) n1 = cur->next;
ListNode* next_node = cur->next->next;
temp = cur->next;
temp->next = NULL;
if (nk->next == NULL) {
nk->next = temp;
}
else {
temp->next = nk->next;
nk->next = temp;
}
cur->next = next_node;
}
if (flag == 1) {
while(nk->next != NULL){
ListNode* first = nk->next;
if(nk->next->next == NULL){
first->next = cur->next;
cur->next = first;
break;
}
ListNode* second = nk->next->next;
first->next = cur->next;
cur->next = first;
nk->next = second;
}
break;
}
n1->next = cur->next;
cur->next = nk->next;
cur = n1;
}
return res->next;
}
};