24. Swap Nodes in Pairs
https://leetcode.com/problems/swap-nodes-in-pairs/
solution
可以一次移动两步,实现交替移动
当前pre和cur,交换的是 cur 和 cur.next
# 0(dummy) -> 1 -> 2 -> 3 -> 4
class Solution:
def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
dummy = ListNode(-1, next=head)
pre = dummy
cur = head
while cur and cur.next:
temp = cur.next.next # 3
cur.next.next = cur # 2 -> 1
pre.next = cur.next # 0 -> 2
cur.next = temp # 1 -> 3
pre = cur # 向后移动 -1 > 1
cur = cur.next # 向后移动 1 > 3. 由于1已经挪到3前面了,实现按pair
return dummy.next
时间复杂度:O() 空间复杂度:O()
class Solution:
def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
dummy = ListNode(next=head)
cur = dummy
while cur.next is not None and cur.next.next is not None:
tmp1 = cur.next # 被间隔的线隔开
tmp2 = cur.next.next.next # 被后面隔离
cur.next = cur.next.next
cur.next.next = tmp1
cur.next.next.next = tmp2
cur = cur.next.next # 展开第一轮后可确定是两步
return dummy.next
时间复杂度:O(n) 空间复杂度:O(1)
follow up
迭代法
# https://www.geeksforgeeks.org/reverse-a-linked-list-in-groups-of-given-size/
时间复杂度:O(n) 空间复杂度:O(1)
递归法
class Solution:
def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
if not head:
return
tail = head
for _ in range(k):
if not tail:
return head
tail = tail.next
new_head = self.reverse(head, tail)
head.next = self.reverseKGroup(tail, k)
return new_head
def reverse(self, head, tail):
prev = None
cur = head
while cur != tail:
temp = cur.next
cur.next = prev
prev = cur
cur = temp
return prev
时间复杂度:O(n) 空间复杂度:O(n)
class Solution:
def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
# Check if we need to reverse the group
curr = head
for _ in range(k):
if not curr:
return head
curr = curr.next
# Reverse the group (basic way to reverse linked list)
prev = None
curr = head
for _ in range(k):
nxt = curr.next
curr.next = prev
prev = curr
curr = nxt
# After reverse, we know that `head` is the tail of the group.
# And `curr` is the next pointer in original linked list order
head.next = self.reverseKGroup(curr, k)
return prev
栈的思路更直白一些
# https://zhuanlan.zhihu.com/p/674723050
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
Last updated