一、Python
自己写的。
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
#
# 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
#
#
# @param head ListNode类
# @param k int整型
# @return ListNode类
#
class Solution:
def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
# write code here
if head:
h1 = ListNode(0)
h1.next = head
ansHead = h1
h2 = head
while h2 is not None:
# 用test判断是否为最后一组
test = h2
flag = 0
for i in range(k):
if test is not None:
test = test.next
else:
flag = 1 # 最后一组没有k个
break
if flag == 0:
for i in range(k - 1): # for i in range(k)是错的
h3 = h2.next # h3是每次要往前提的结点
h4 = h3.next # h4是h3的后一个结点
h3.next = h1.next # h3.next = h1是错的
h1.next = h3 # 将h3往前提
h2.next = h4
# 进入下一组
h1 = h2
h2 = h1.next
else:
return ansHead.next
return ansHead.next
评论中用数组的方法:核心思想是将链表节点值取出放至数组内,在数组内调整各元素位置,最后将调整好位置的元素按顺序赋值给链表各节点。
class Solution:
def reverseKGroup(self , head: ListNode, k: int) -> ListNode:
# 创建空列表存放链表节点数值
var_list = []
cur = head
# 遍历链表,将链表节点值取出追加到数组内
while cur:
var_list.append(cur.val)
cur = cur.next
# 将数组长度对k取商,数组前n*k位元素就是需要调整顺序的,n*k以后的顺序不变
n = len(var_list)//k
# 如果列表元素少于k个,直接返回原链表
if not n:
return head
# 调整列表元素顺序
else:
for i in range(n):
for j in range(k):
min_index = i*k+j
max_index = (i+1)*k-j-1
if min_index <= max_index:
var_list[min_index],var_list[max_index] = var_list[max_index],var_list[min_index]
cur = head
# 将调整好顺序的列表各元素按顺序赋值给链表节点
while cur :
cur.val = var_list.pop(0)
cur = cur.next
return head
评论中用递归的方法:额外增加了一个新的链表,而且在考虑最后一组也非常巧妙。
class Solution:
def reverse(self, head, k):
p = head
if head is None:
return p
end = ListNode(head.val)
start = end
for i in range(1, k):
if head is None: # 最后一组在这里考虑,非常巧妙
return p
if head.next is None:
return p
head = head.next
node = ListNode(head.val)
node.next = start
start = node
end.next = self.reverse(head.next, k)
return start
def reverseKGroup(self , head: ListNode, k: int) -> ListNode:
if head is None:
return head
start = self.reverse(head, k)
return start
评论中回复最高的和我的方法类似。
class Solution:
def reverseKGroup(self , head: ListNode, k: int) -> ListNode:
# write code here
res=ListNode(0)
res.next=head
pre=res # 指向进行反转部分链表的前序
cur=head # 指向进行反转部分链表头
while cur:
tail=cur
for i in range(0,k): # 判断要不要翻转
if tail==None:
return res.next
else: tail=tail.next
for i in range(1,k): # 翻转
temp=cur.next
cur.next=temp.next
temp.next=pre.next
pre.next=temp
cur=cur.next # 指向下一部分列表头
for i in range(0,k):
pre=pre.next
return res.next
二、c++
自己写的(与速刷模板不同):
调试很久的地方:第二个for循环也要循环k次,而不是k-1次。因为每组第一个元素都指向了NULL。
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* ListNode(int x) : val(x), next(nullptr) {}
* };
*/
class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param head ListNode类
* @param k int整型
* @return ListNode类
*/
ListNode* reverseKGroup(ListNode* head, int k) {
// write code here
ListNode* tail = head;
for (int i = 0; i < k; i++) {
if (tail == NULL)
return head;
tail = tail -> next;
}
ListNode* pre = NULL;
ListNode* cur = head;
for (int i = 0; i < k; i++) {
ListNode* temp = cur->next;
cur->next = pre;
pre = cur;
cur = temp;
}
head->next = reverseKGroup(tail, k);
return pre;
}
};