25. 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* reverseBetween(ListNode* head, int left, int right) {
// 使用虚拟头节点避免头节点变化的分类讨论
ListNode *dummyNode = new ListNode(-1);
dummyNode->next = head;
ListNode *pre = dummyNode;
//1. 从虚拟头节点走left-1步, 来到left节点的前一个节点,也就是待反转子链表的前驱
for(int i = 0; i < left - 1; i++){
pre = pre->next;
}
//2.从pre再走right-left+1步,来到right节点,rightNode节点就是待反转子链表的末尾节点
ListNode *rightNode = pre;
for(int i = 0; i < right - left + 1; i++){
rightNode = rightNode->next;
}
//3.切断出一个子链表
// leftNode节点就是待反转子链表的开始节点
ListNode *leftNode = pre->next;
// succ是待反转子链表的后继节点
ListNode *succ = rightNode->next;
// 把待反转子链表切割出来
pre->next = nullptr;
rightNode->next = nullptr;
//4.反转链表的子区间;用头插法
ListNode *tempDummy = new ListNode(-1);
ListNode *tempCur = leftNode;
while(tempCur){
ListNode *nextHead = tempCur->next;
tempCur->next = tempDummy->next;
tempDummy->next = tempCur;
tempCur = nextHead;
}
//5.接回到原来的链表中,所有之前需要记录待反转子链表的前驱和后继
pre->next = rightNode;
leftNode->next = succ;
return dummyNode->next;
}
ListNode* reverseKGroup(ListNode* head, int k) {
ListNode *num = head;
int length = 0;
while(num){
length++;
num = num->next;
}
ListNode *res = head;
for(int i = 1; i*k <= length; i++){
res = reverseBetween(res, i*k-k+1 , i*k);
}
return res;
}
};
/**
* 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* reverseBetween(ListNode* head, int left, int right) {
// 使用虚拟头节点避免头节点变化的分类讨论
ListNode *dummyNode = new ListNode(-1);
dummyNode->next = head;
ListNode *pre = dummyNode;
//1. 从虚拟头节点走left-1步, 来到left节点的前一个节点,也就是待反转子链表的前驱
for(int i = 0; i < left - 1; i++){
pre = pre->next;
}
//2.从pre再走right-left+1步,来到right节点,rightNode节点就是待反转子链表的末尾节点
ListNode *rightNode = pre;
for(int i = 0; i < right - left + 1; i++){
rightNode = rightNode->next;
}
//3.切断出一个子链表
// leftNode节点就是待反转子链表的开始节点
ListNode *leftNode = pre->next;
// succ是待反转子链表的后继节点
ListNode *succ = rightNode->next;
// 把待反转子链表切割出来
pre->next = nullptr;
rightNode->next = nullptr;
//4.反转链表的子区间;直接改变节点指针的指向
ListNode *tempPre = nullptr; // 便于第一个节点的next指针改变指向
ListNode *tempCur = leftNode;
while(tempCur){
// 记录下一个节点,确保tempCur的指针指向改变之后仍然能够找到原链表中tempCur的下一个节点
ListNode *next = tempCur->next;
// 当前的节点指向前一个节点,达到反转的效果
tempCur->next = tempPre;
// 两个指针都往后挪一个
tempPre = tempCur;
tempCur = next;
}
//5.接回到原来的链表中,所有之前需要记录待反转子链表的前驱和后继
pre->next = rightNode;
leftNode->next = succ;
return dummyNode->next;
}
ListNode* reverseKGroup(ListNode* head, int k) {
ListNode *num = head;
int length = 0;
while(num){
length++;
num = num->next;
}
ListNode *res = head;
for(int i = 1; i*k <= length; i++){
res = reverseBetween(res, i*k-k+1 , i*k);
}
return res;
}
};
方法二
/**
* 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:
// 翻转一个子链表,直接改变next指针的指向
ListNode *reverse(ListNode* head){
// 创建一个空的头节点,便于第一个节点next指针指向的改变
ListNode* pre = nullptr;
ListNode* cur = head;
while(cur){
// 记录下一个节点,确保cur指向改变之后仍然能够找到原链表中cur的下一个节点
ListNode* nextNode = cur->next;
// 当前的节点指向前一个节点,达到反转的效果
cur->next = pre;
// pre和cur都往后挪一个
pre = cur;
cur = nextNode;
}
return pre;
}
ListNode* reverseKGroup(ListNode* head, int k) {
// 创建虚拟头节点
ListNode* dummy = new ListNode(-1);
dummy->next = head;
// 1.找待反转子链表的前驱pre、后继succ以及待反转子链表的第一个节点start和最后一个节点end,并且把待反转的子链表通过end->next=nullptr的方式从原链表中切下,进行反转,最后再把反转好的子链表接到原链表中
// 待反转子链表的前驱节点
ListNode* pre = dummy;
// 待反转子链表的第一个节点
ListNode* start = pre->next;
// 待反转子链表的最后一个节点
ListNode* end = dummy;
while(end->next){
// 找待反转子链表的最后一个节点
for(int i = 0; i < k && end; i++){
end = end->next;
}
if(!end){
break;
}
// 待反转子链表的后继节点
ListNode* succ = end->next;
// 把待反转的子链表从原链表中切断
end->next = nullptr;
// 前驱节点的下一个节点就是待反转子链表反转之后的第一个节点
pre->next = reverse(start);
// 反转之后start就成了反转链表的最后一个节点,将反转之后的最后一个节点链接到前一轮记录的后继节点上
start->next = succ;
// 2.调整新一轮的待反转子链表的前驱pre以及待反转子链表的第一个节点start和最后一个节点end
// 调整新一轮的前驱节点,指向待反转链表反转之后的最后一个节点,也就是反转之前的start
pre = start;
// 调整新一轮的后继节点,指向待反转链表反转之后的最后一个节点,也就是反转之前的start
start = succ;
// 调整新一轮待反转链表的最后一个节点
end = pre;
}
return dummy->next;
}
};