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 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 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 removeElements(self, head: ListNode, val: int) -> ListNode:
ans = node = ListNode(0)
while head:
if head.val != val:
node.next = ListNode(head.val)
node = node.next
head = head.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 addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
ans = node = ListNode(None) # 返回结果 当前节点
now = 0 # 进位计数
while l1 or l2 or now:
now += (l1.val if l1 else 0) + (l2.val if l2 else 0)
node.next = ListNode(now % 10)
node = node.next
now //= 10
l1 = l1.next if l1 else None
l2 = l2.next if l2 else None
return ans.next
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
ans = node = ListNode(None)
carry = 0
while l1 or l2 or carry:
val = carry + (l1.val if l1 else 0) + (l2.val if l2 else 0)
node.next = ListNode(val % 10)
carry = val // 10
node = node.next
l1 = l1.next if l1 else None
l2 = l2.next if l2 else None
return ans.next
def deleteDuplicates(self, head: ListNode) -> ListNode:
ans = node = ListNode(0)
while head:
if head.next:
if head.val != head.next.val:
node.next = ListNode(head.val)
node = node.next
else:
node.next = ListNode(head.val)
node = node.next
head = head.next
return ans.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 mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
ans = node = ListNode(0)
while l1 or l2:
if l1 and (l2 is None or l1.val <= l2.val):
node.next = ListNode(l1.val)
l1 = l1.next
else:
node.next = ListNode(l2.val)
l2 = l2.next
node = node.next
return ans.next
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
ans = node = ListNode(0)
while any(lists):
min_node = ListNode(float("inf"))
min_num = -1
for i in range(len(lists)):
if lists[i] is not None and lists[i].val < min_node.val:
min_num = i
min_node = ListNode(lists[i].val)
lists[min_num] = lists[min_num].next
node.next = min_node
node = node.next
return ans.next
def partition(self, head: ListNode, x: int) -> ListNode:
headA = nodeA = ListNode(0)
headB = nodeB = ListNode(0)
while head:
if head.val < x:
nodeA.next = ListNode(head.val)
nodeA = nodeA.next
else:
nodeB.next = ListNode(head.val)
nodeB = nodeB.next
head = head.next
nodeA.next = headB.next
return headA.next
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
values = []
for linked in lists:
while linked:
values.append(linked.val)
linked = linked.next
values.sort()
ans = node = ListNode(0)
for v in values:
node.next = ListNode(v)
node = node.next
return ans.next
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
ans = node = ListNode(0)
while l1 and l2:
if l1.val <= l2.val:
node.next = ListNode(l1.val)
node = node.next
l1 = l1.next
else:
node.next = ListNode(l2.val)
node = node.next
l2 = l2.next
if l1 or l2:
node.next = l1 or l2
return ans.next
def helper(listNode1, listNode2):
ans = node = ListNode(0)
while listNode1 and listNode2:
if listNode1.val < listNode2.val:
node.next = ListNode(listNode1.val)
listNode1 = listNode1.next
node = node.next
else:
node.next = ListNode(listNode2.val)
listNode2 = listNode2.next
node = node.next
if listNode1 or listNode2:
node.next = listNode1 or listNode2
return ans.next
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
import heapq
values = []
for node in lists:
while node:
heapq.heappush(values, node.val)
node = node.next
ans = node = ListNode(0)
while values:
node.next = ListNode(heapq.heappop(values))
node = node.next
return ans.next
def helper(head1, head2):
ans = node = ListNode(0)
while head1 and head2:
if head1.val < head2.val:
node.next = ListNode(head1.val)
node = node.next
head1 = head1.next
else:
node.next = ListNode(head2.val)
node = node.next
head2 = head2.next
if head1 or head2:
node.next = head1 or head2
return ans.next
def listOfDepth(self, tree: TreeNode) -> List[ListNode]:
ans = []
tree_nodes = collections.deque([tree])
while tree_nodes:
head = node = ListNode(0)
for i in range(len(tree_nodes)):
now = tree_nodes.popleft()
if now.left:
tree_nodes.append(now.left)
if now.right:
tree_nodes.append(now.right)
node.next = ListNode(now.val)
node = node.next
ans.append(head.next)
return ans
def insertionSortList(self, head: ListNode) -> ListNode:
# 处理特殊情况
if not head or not head.next:
return head
# 插入排序
ans = ListNode(float("-inf"))
last = ans
node = head
while node:
# 寻找插入位置
if last.val < node.val:
point = node.next
node.next = None
last.next = node
last = last.next
node = point
else:
curr = ans
while curr.next and curr.next.val < node.val:
curr = curr.next
# 执行插入
point = node.next
node.next = curr.next
curr.next = node
node = point
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 removeElements(self, head: ListNode, val: int) -> ListNode:
ans = node = ListNode(0)
ans.next = node.next = head
while node and node.next:
while node.next and node.next.val == val:
node.next = node.next.next
node = node.next
return ans.next
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
# 计算l1的长度
size1 = 0
node1 = l1
while node1:
node1 = node1.next
size1 += 1
node1 = l1
# 计算l2的长度
size2 = 0
node2 = l2
while node2:
node2 = node2.next
size2 += 1
node2 = l2
maximum = max(size1, size2)
ans = node = ListNode(0)
stack = [node]
for i in range(maximum, 0, -1):
value = 0
if size1 >= i:
value += node1.val
node1 = node1.next
if size2 >= i:
value += node2.val
node2 = node2.next
if value >= 10:
for j in range(len(stack) - 1, -1, -1):
stack[j].val += 1
if stack[j].val == 10:
stack[j].val = 0
else:
break
node.next = ListNode(value % 10)
node = node.next
stack.append(node)
if ans.val:
return ans
else:
return ans.next
def deleteDuplicates(self, head: ListNode) -> ListNode:
# 处理特殊情况
if not head:
return None
# 遍历删除重复值
ans = node = ListNode(0)
while head:
if not head.next or head.val != head.next.val:
node.next = ListNode(head.val)
node = node.next
head = head.next
else:
val = head.val
while head and head.val == val:
head = head.next
return ans.next
def swapPairs(self, head: ListNode) -> ListNode:
ans = node = ListNode(0)
ans.next = head
while node.next and node.next.next:
node1 = node.next
node2 = node.next.next
node1.next = node2.next
node2.next = node1
node.next = node2
node = node.next.next
return ans.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 addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
ans = ListNode(0) # 返回结果
carry = 0 # 进位计数
node = ans # 当前位
while True:
value = carry
if l1:
value += l1.val
l1 = l1.next
if l2:
value += l2.val
l2 = l2.next
node.val = value % 10
carry = value // 10
if l1 or l2 or carry == 1:
node.next = ListNode(0)
node = node.next
else:
break
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 mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
ans = node = ListNode(0)
while l1 or l2:
if not l1:
node.next = l2
break
if not l2:
node.next = l1
break
if l1.val <= l2.val:
node.next = ListNode(l1.val)
l1 = l1.next
else:
node.next = ListNode(l2.val)
l2 = l2.next
node = node.next
return ans.next
