题目
给你一个链表,每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]
示例 3:
输入:head = [1,2,3,4,5], k = 1
输出:[1,2,3,4,5]
翻转
算法思路
这是一个典型的链表节点交换问题,算是LeetCode 206题反转链表的一个扩展。那么我们想要针对k对链表进行分组翻转,首先我们需要把链表中的节点按照K个一组分组,为了要实现每K个节点一组的效果,所以我们在每次遍历中将head向前走k步,并标记出当前分组的tail尾节点。这样一来从head到tail之间的节点就是我们本次需要翻转的节点。
该题的翻转比LeetCode 24题两两交换要复杂一些,因为这里的需要翻转的节点数是未知的,所以我们需要单独对head到tail之间的节点进行遍历,每次将遍历得到的节点连接到上一次遍历的进行翻转的节点上。为了满足以上效果,我们需要定义一个reverseTail来作为每次遍历需要翻转节点,并在每次遍历翻转后进行更新;除此之外还需要定义一个reverseHead用来标记翻转节点需要连接的后继节点,也就是上一次遍历翻转的那个节点。
最后我们还需要将每个翻转后的分组连接起来,所以需要定义一个prev节点用于连接各个分组,prev在每次遍历中更新其值,每次都将其更新为前一个分组的尾节点,这样一来就可以在下一次遍历时连接下一个翻转后的分组。
编码
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution{
public ListNode reverseKGroup(ListNode head, int k) {
if(head == null || k <= 0){
return head;
}
// 定义一个统领所有节点的辅助节点
ListNode leader = new ListNode(-1);
leader.next = head;
// 定义一个前驱节点,用于连接各分组
ListNode prev = leader;
while(head != null){
// 定义一个尾节点,每次向前走k步
ListNode tail = prev;
for(int i=0; i<k; i++){
tail = tail.next;
if(tail == null){
return leader.next;
}
}
// 每次遍历进行翻转时,尾节点要连接的后继节点
ListNode reverseHead = tail.next;
// 每次遍历进行翻转时,当前需要处理的尾节点
ListNode reverseTail = head;
while(reverseHead != tail){
// 翻转节点
ListNode nextTail = reverseTail.next;
reverseTail.next = reverseHead;
reverseHead = reverseTail;
reverseTail = nextTail;
}
// 通过定义的前驱节点,连接各个分组
prev.next = reverseHead;
// 指定下一次遍历的前驱节点
prev = head;
// 指定下一次遍历的首节点
head = reverseTail;
}
return leader.next;
}
}
复杂度分析
时间复杂度为O(n),其中n是链表的长度,因为我们要对链表进行一次遍历,每次遍历又会根据k值向前走k个节点并进行翻转,所以综合复杂度就为O(n)。因为没有开辟任何额外的内存空间,所以空间复杂度为O(1)。