题目描述(困难程度)
给你一个链表,每 k
个节点一组进行翻转,请你返回翻转后的链表。k
是一个正整数,它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。
解法一 迭代
一图胜千言,根据图片看代码,马上就懂了
步骤分解:
- 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)
,最差的情况未O(n^2)
- 9.空间复杂度为
O(1)
除了几个必须的节点指针外,我们并没有占用其他空间
Java
class ListNode{
int val;
ListNode next;
ListNode(int val){
this.val=val;
}
}
public class Reverse_Nodes_in_k_Group {
public ListNode reverseKGroup(ListNode head, int k) {
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode pre = dummy;
ListNode end = dummy;
while (end.next != null) {
for (int i = 0; i < k && end != null; i++) end = end.next;
if (end == null) break;
ListNode start = pre.next;
ListNode next = end.next;
end.next = null;
pre.next = reverse(start);
start.next = next;
pre = start;
end = pre;
}
return dummy.next;
}
private ListNode reverse(ListNode head) {
ListNode pre = null;
ListNode curr = head;
while (curr != null) {
ListNode next = curr.next;
curr.next = pre;
pre = curr;
curr = next;
}
return pre;
}
public static void main(String args[]) {
ListNode head=new ListNode(1);
ListNode p=head;
p.next=new ListNode(2);
p=p.next;
p.next=new ListNode(3);
p=p.next;
p.next=new ListNode(4);
p=p.next;
p.next=new ListNode(5);
int k=2;
ListNode ans=reverseKGroup(head,k);
while(ans!=null) {
System.out.println(ans.val);
ans=ans.next;
}
}
}
Python
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution(object):
def reverseKGroup(self, head, k):
dummy = ListNode(0)
dummy.next = head
pre = dummy
end = dummy
while(end.next!=None):
for i in range(0,k):
if(end!=None):
end=end.next
if end==None:
break
start = pre.next
next = end.next
end.next=None
pre.next=self.reverse(start)
start.next=next
pre=start
end=pre
return dummy.next
def reverse(self,head):
pre = None
curr = head
while(curr !=None):
next = curr.next
curr.next = pre
pre = curr
curr = next
return pre
解法二 递归
大致过程可以分解为
- 1、找到待翻转的k个节点(注意:若剩余数量小于 k 的话,则不需要反转,因此直接返回待翻转部分的头结点即可)。
- 2、对其进行翻转。并返回翻转后的头结点(注意:翻转为左闭又开区间,所以本轮操作的尾结点其实就是下一轮操作的头结点)。
- 3、对下一轮 k 个节点也进行翻转操作。
- 4、将上一轮翻转后的尾结点指向下一轮翻转后的头节点,即将每一轮翻转的k的节点连接起来。
具体过程看下图。
public ListNode reverseKGroup(ListNode head, int k) {
if (head == null || head.next == null) {
return head;
}
ListNode tail = head;
for (int i = 0; i < k; i++) {
//剩余数量小于k的话,则不需要反转。
if (tail == null) {
return head;
}
tail = tail.next;
}
// 反转前 k 个元素
ListNode newHead = reverse(head, tail);
//下一轮的开始的地方就是tail
head.next = reverseKGroup(tail, k);
return newHead;
}
/*
左闭又开区间
*/
private ListNode reverse(ListNode head, ListNode tail) {
ListNode pre = null;
ListNode next = null;
while (head != tail) {
next = head.next;
head.next = pre;
pre = head;
head = next;
}
return pre;
}
参考文献
- https://leetcode-cn.com/problems/reverse-nodes-in-k-group/solution/tu-jie-kge-yi-zu-fan-zhuan-lian-biao-by-user7208t/