25. Reverse Nodes in k-Group[H]k个一组翻转链表
题目
Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.
k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.
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
Note:
- Only constant extra memory is allowed.
- You may not alter the values in the list's nodes, only nodes itself may be changed.
思路
先分析题目的几个要求：
- 每k个节点一组进行翻转，返回翻转之后的链表
- 如果节点总数不是k的整数倍，则剩余节点保留原有顺序
- 只能使用常数的额外空间
- 不能只是单纯改变节点的内部值，而是对节点进行交换
分析可知，题目要求实现两个功能，一个是如何实现每k个节点一组；一个是翻转节点。
- 每k个节点分组
- 循环：定义一个变量count记录走过的节点长度。如果count是k的整数倍，就进行翻转；如果不是，继续遍历节点。
- 递归：分别定义节点1（用于记录每个分组结束位置的下一个节点）和节点2（每个分组的第一个节点），递归将节点2到节点1之间的节点翻转。
- 翻转节点
- 头插法
- 记录节点法
这两个功能所用的方法可以自由组合。
思路1：头插法+递归
分组用递归完成：
定义节点lCur记录分组结束位置的下一个节点，通过k循环来找到每个lCur；利用节点head记录每个分组的开始位置。翻转从head到lCur之间的节点，完成一组节点的翻转，得到一组新的节点lHead。此时节点head已经到了分组的最后一位，从后面接上递归调用下一分组得到的新节点lHead，并返回新节点。
翻转用头插法完成（实现方法见Tips）：
头插法以链表1->2->3->4->5为例子，假设k=5，完成如下图过程：
思路2：记录节点法+循环
分组用循环完成，翻转用记录节点完成（实现方法见Tips）。
以链表1->2->3->4->5为例子，假设k=4，完成如下过程：
2->1->3->4->5
3->2->1->4->5
4->3->2->1->5
如上是4个一组的节点翻转，每行代表一次循环。
Tips
节点的翻转有两种方法
（1）头插法
新建一个虚拟节点dummy，并保证虚拟节点连接链表的头节点。每当遍历到一个节点时，就把它连接到虚拟节点的下一个节点（整个链表的头部）。定义pCur为当前要翻转的节点，过程如下：
//Step1：新建一个节点记录下一个要翻转的节点
ListNode* pNext = pCur->next;
//Step2：将pCur置于整个节点的头部（即已经翻转好的节点的头部，完成翻转）
pCur->next = dummy->next;
//Step1：更新虚拟节点dummy的指向，使其指向链表的头节点
dummy->next = pCur;
//Step4：更新当前节点，将其置于下一个要翻转的节点
pCur = pNext;
翻转的过程如图所示（以要翻转的节点的值为3为例）：
（2）记录节点法
pCur表示当前要翻转的节点，pPre表示当前要翻转的前一个节点（也是已经完成翻转操作的最后一个节点），一次翻转过程（一次循环）如下：
// Step1：pPre连接下一个要翻转的节点
pPre->next = pCur->next;
// Step2：pCur节点连接已经翻转好的节点（翻转当前节点）
pCur->next = dummy->next;
// Step3：更改虚拟节点的连接，使它指向已经翻转好的节点
dummy->next = pCur;
// Step4：pCur指向下一个要翻转的节点
pCur = pPre->next;
翻转的过程如图2所示：
- 思路1
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseKGroup(ListNode* head, int k) {
ListNode* lCur =head; //该节点用于记录每组节点结束后的下一个节点
//循环找到每组结束的下一个节点
for(int i= 0 ; i < k; i++){
if(lCur == nullptr)
return head;
lCur = lCur->next;
}
ListNode* lHead = reverseOneGroup(head,lCur);
head->next = reverseKGroup(lCur, k);
return lHead;
}
/**
* @Description:头插法实现一组节点内的翻转
* lHead：当前一组节点的头节点
* lTail：当前一组节点结束位置的下一个节点
*/
ListNode* reverseOneGroup(ListNode* lHead, ListNode* lTail){
ListNode* dummy = new ListNode(-1);
ListNode* lCur = lHead;
while(lCur != lTail){
ListNode* lNext = lCur->next;
lCur->next = dummy->next;
dummy->next = lCur;
lCur = lNext;
}
return dummy->next;
}
};
- 思路2
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseKGroup(ListNode* head, int k) {
//特殊情况
if(head == nullptr || k ==1)
return head;
//辅助的虚拟节点
ListNode* dummy = new ListNode(-1);
//当前节点的上一个节点
ListNode* lPre = dummy;
//当前节点
ListNode* lCur = head;
dummy->next = head;
int count = 0; //记录长度
while(lCur != nullptr){
count ++;
if(count % k ==0){
lPre = reverseOneGroup(lPre, lCur->next);
lCur = lPre->next;
}
else{
lCur = lCur->next;
}
}
return dummy->next;
}
/**
* @Description：记录节点法实现一组节点内的翻转
* lPre：当前一组节点的上一个节点
* lNext:当前一组节点的下一个节点
*/
ListNode* reverseOneGroup(ListNode* lPre, ListNode* lNext){
ListNode* lEnd = lPre->next;
ListNode* lCur = lEnd->next;
while(lCur != lNext){
lEnd->next = lCur->next;
lCur->next = lPre->next;
lPre->next = lCur;
lCur = lEnd->next;
}
return lEnd;
}
};
Python
参考
[1] https://www.cnblogs.com/byrhuangqiang/p/4311336.html
[2] https://www.cnblogs.com/grandyang/p/4441324.html
