def reorderList(self, head: ListNode) -> None:
# 处理特殊情况
if not head or not head.next:
return
# 寻找链表中点
slow = fast = head
fast = fast.next.next
while fast and fast.next:
slow = slow.next
fast = fast.next.next
# 移除后半部分链表
curr = slow.next
slow.next = None
# 翻转链表后半部分
reverse = None
while curr:
point = curr.next
curr.next = reverse
reverse = curr
curr = point
# 重排链表
while head and head.next:
point = reverse.next
reverse.next = head.next
head.next = reverse
head = head.next.next
reverse = point
if reverse:
head.next = reverse
def reorderList(self, head: ListNode) -> None:
# 处理特殊情况
if not head or not head.next:
return
# 寻找链表中点
slow = fast = head
fast = fast.next.next
while fast and fast.next:
slow = slow.next
fast = fast.next.next
# 翻转链表后半部分
curr = slow.next
while curr and curr.next:
now = ListNode(curr.next.val)
now.next = slow.next
slow.next = now
curr.next = curr.next.next
# 重排链表
node = head
while node != slow and slow.next:
now = ListNode(slow.next.val)
now.next = node.next
node.next = now
node = node.next.next
slow.next = slow.next.next
def reverseList(self, head: ListNode) -> ListNode:
if head:
ans = ListNode(0)
ans.next = head
node = head.next
head.next = None
while node:
temp = ans.next
ans.next = node
node = node.next
ans.next.next = temp
return ans.next
def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
ans = node = ListNode(0)
ans.next = head
while node:
# 判断链表剩余长度是否充足
curr = node
is_enough = True
for _ in range(k):
if curr is None or curr.next is None:
is_enough = False
break
curr = curr.next
if not is_enough:
break
# 翻转链表
curr = node.next
for _ in range(k - 1):
now = ListNode(curr.next.val)
now.next = node.next
node.next = now
curr.next = curr.next.next
node = curr
return ans.next
def isPalindrome(self, head: ListNode) -> bool:
if head is None or head.next is None:
return True
# 定位到链表中点（奇数个为绝对中点，偶数个为中线右侧）
slow = head
fast = head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
# 翻转链表中点后半段链表
reverse = None
while slow:
temp = ListNode(slow.val)
temp.next = reverse
reverse = temp
slow = slow.next
# print(reverse, head)
# 比较翻转后的后半段链表与前半段链表是否相同（如果为奇数则最后一次比较中点和中点自己是否相同）
while reverse:
if reverse.val != head.val:
# print(reverse.val, head.val)
return False
head = head.next
reverse = reverse.next
else:
return True
def rotateRight(self, head: ListNode, k: int) -> ListNode:
if not head:
return None
size = 0
node = head
while node:
node = node.next
size += 1
k = k % size
start = head
ans = node = ListNode(0)
for _ in range(size - k):
node.next = ListNode(start.val)
node = node.next
start = start.next
node = ans
while start:
now = ListNode(start.val)
now.next = node.next
node.next = now
node = node.next
start = start.next
return ans.next
def reverseList(self, head: ListNode) -> ListNode:
ans = None
while head:
node = ListNode(head.val)
node.next = ans
ans = node
head = head.next
return ans
def removeZeroSumSublists(self, head: ListNode) -> ListNode:
ans = ListNode(0)
ans.next = head
hashmap = {0: ans}
sum_ = 0
while head:
sum_ += head.val
hashmap[sum_] = head
head = head.next
head = ans
sum_ = 0
while head:
sum_ += head.val
head.next = hashmap[sum_].next
head = head.next
return ans.next
def oddEvenList(self, head: ListNode) -> ListNode:
odd_head = odd_node = ListNode(0)
even_head = even_node = ListNode(0)
is_odd = True
while head:
point = head.next
head.next = None
if is_odd:
odd_node.next = head
odd_node = odd_node.next
else:
even_node.next = head
even_node = even_node.next
is_odd = not is_odd
head = point
odd_node.next = even_head.next
return odd_head.next
def removeZeroSumSublists(self, head: ListNode) -> ListNode:
ans = ListNode(0)
ans.next = head
while True:
hashmap = {0: ans}
sum_ = 0
node = ans.next
while node:
sum_ += node.val
if sum_ not in hashmap:
hashmap[sum_] = node
else:
hashmap[sum_].next = node.next
break
node = node.next
else:
break
return ans.next
def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
# 处理特殊情况
if not head:
return None
# 找到翻转部分的前一个元素
ans = node = ListNode(0)
ans.next = head
for _ in range(m - 1):
node = node.next
# 翻转链表
curr = node.next
for _ in range(n - m):
now = ListNode(curr.next.val)
now.next = node.next
node.next = now
curr.next = curr.next.next
return ans.next
def isPalindrome(self, head: ListNode) -> bool:
# 寻找链表中点（快慢针法）
slow = fast = head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
# 翻转后半部分链表
reverse = None
while slow:
node = ListNode(slow.val)
node.next = reverse
reverse = node
slow = slow.next
# 比较链表是否相同
while reverse:
if reverse.val != head.val:
return False
head = head.next
reverse = reverse.next
else:
return True
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
stack1 = []
while l1:
stack1.append(l1.val)
l1 = l1.next
stack2 = []
while l2:
stack2.append(l2.val)
l2 = l2.next
ans = None
carry = 0
while stack1 or stack2 or carry > 0:
n1 = stack1.pop() if stack1 else 0
n2 = stack2.pop() if stack2 else 0
value = n1 + n2 + carry
carry = value // 10
node = ListNode(value % 10)
node.next = ans
ans = node
return ans
def sortList(self, head: ListNode) -> ListNode:
# 计算链表长度
size, node = 0, head
while node:
node = node.next
size += 1
# 定义处理变量
ans = ListNode(0)
ans.next = head
# 归并排序
ps = 1
while ps < size:
pre = ans
node = ans.next
for i in range(0, size, ps * 2):
if size - i <= ps:
break
# 获取两段链表的头
node1 = node
for _ in range(ps):
node = node.next
node2 = node
for _ in range(ps):
if node:
node = node.next
# 计算两段链表的长度
size1 = ps
size2 = min(ps, size - i - ps)
# 排序两个排序链表
while size1 > 0 and size2 > 0:
if node1.val < node2.val:
point = node1.next
pre.next = node1
node1 = point
size1 -= 1
else:
point = node2.next
pre.next = node2
node2 = point
size2 -= 1
pre = pre.next
if size1 > 0:
pre.next = node1
if size2 > 0:
pre.next = node2
while size1 > 0 or size2 > 0:
pre = pre.next
size1 -= 1
size2 -= 1
pre.next = node
ps *= 2
return ans.next