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