点击上方“码侬进阶之路”,选择“星标”公众号
资源干货,与你分享
题目描述:
给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。
k 是一个正整数,它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。
示例 :
给定这个链表:1->2->3->4->5
当 k = 2 时,应当返回: 2->1->4->3->5
当 k = 3 时,应当返回: 3->2->1->4->5
分析:
步骤分解:
1.链表分区为已翻转部分+待翻转部分+未翻转部分
2.每次翻转前,要确定翻转链表的范围,这个必须通过 k 此循环来确定
3.需记录翻转链表前驱和后继,方便翻转完成后把已翻转部分和未翻转部分连接起来
4.初始需要两个变量 pre 和 end,pre 代表待翻转链表的前驱,end 代表待翻转链表的末尾
5.经过k此循环,end 到达末尾,记录待翻转链表的后继 next = end.next
6.翻转链表,然后将三部分链表连接起来,然后重置 pre 和 end 指针,然后进入下一次循环
7.特殊情况,当翻转部分长度不足 k 时,在定位 end 完成后,end==null,已经到达末尾,说明题目已完成,直接返回即可
8.时间复杂度为 O(n*K)O(n∗K) 最好的情况为 O(n)O(n) 最差的情况未 O(n^2)O(n2)
9.空间复杂度为 O(1)O(1) 除了几个必须的节点指针外,我们并没有占用其他空间
Java代码实现(递归):
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
ListNode prev = null;
ListNode cur = head;
ListNode next = null;
ListNode check = head;
int canProceed = 0;
int count = 0;
// 检查链表长度是否满足翻转
while (canProceed < k && check != null) {
check = check.next;
canProceed++;
}
// 满足条件,进行翻转
if (canProceed == k) {
while (count < k && cur != null) {
next = cur.next;
cur.next = prev;
prev = cur;
cur = next;
count++;
}
if (next != null) {
// head 为链表翻转后的尾节点
head.next = reverseKGroup(next, k);
}
// prev 为链表翻转后的头结点
return prev;
} else {
// 不满住翻转条件,直接返回 head 即可
return head;
}
}
}
C/C++代码实现:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode *reverseKGroup( struct ListNode *head, int k ) {
struct ListNode *front = NULL, *start = NULL, *end = NULL, *newHead = NULL;
struct ListNode **stack = NULL, *t = NULL;
int size = 0, group = 0, i = 0, stackTop = 0;
for( start = head; start != NULL; start = start->next ) { // 总共有的节点数.
++size;
}
if( head == NULL || size < k ) {
return head;
}
stack = (struct ListNode **) malloc( sizeof(*stack) * k );
for( group = size / k; group > 0; --group ) { // 每k个为一组进行翻转.
start = end != NULL ? end->next : head; // 每组的开始位置.
for( i = 0; i < k; ++i ) { // 将开始位置起前k个都压入栈.
stack[stackTop++] = start;
start = start->next;
}
// front等于NULL时, 说明是第一组进行翻转, 进行第一组翻转时, 更新新的头指针.
front == NULL ? newHead = stack[stackTop - 1] : (front->next = stack[stackTop - 1]);
end = stack[--stackTop];
t = end->next; // 备份指针.
while( stackTop > 0 ) {
end->next = stack[--stackTop];
end = end->next;
}
end->next = t;
front = end;
}
free( stack );
return newHead;
}
Python3代码实现:
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
dummy = ListNode(0)
p = dummy
while True:
count = k
stack = []
tmp = head
while count and tmp:
stack.append(tmp)
tmp = tmp.next
count -= 1
# 注意,目前tmp所在k+1位置
# 说明剩下的链表不够k个,跳出循环
if count :
p.next = head
break
# 翻转操作
while stack:
p.next = stack.pop()
p = p.next
#与剩下链表连接起来
p.next = tmp
head = tmp
return dummy.next