def mergeTwoLists2(self, l1: ListNode, l2: ListNode) -> ListNode: #递归 #时间复杂度O(n+m) 空间复杂度O(n+m) if not l1: return l2 elif not l2: return l1 elif l1.value <= l2.value: l1.next = self.mergeTwoLists2(l1.next, l2) return l1 elif l2.value < l1.value: l2.next = self.mergeTwoLists2(l1, l2.next) return l2
def reverseList1(self, head: ListNode) -> ListNode: # 递归 if not head or not head.next: return head p = self.reverseList1(head.next) head.next.next = head head.next = None return p
def sortList2(self, head: ListNode) -> ListNode: if not head: return # 时间复杂度O(n logn) 空间复杂度O(1) def merge(l1, l2): dummy_head = ListNode(-1) l = dummy_head while l1 and l2: if l1.value <= l2.value: l.next = l1 l1 = l1.next else: l.next = l2 l2 = l2.next l = l.next l.next = l2 if l2 else l1 return dummy_head.next length = 0 node = head while node: length += 1 node = node.next dummyHead = ListNode(-1) dummyHead.next =head subLength = 1 while subLength < length: prev, curr = dummyHead, dummyHead.next while curr: head1 = curr for i in range(1, subLength): if curr.next: curr = curr.next else: break head2 = curr.next curr.next = None curr = head2 for i in range(1, subLength): if curr and curr.next: curr = curr.next else: break succ = None if curr: succ = curr.next curr.next = None merged = merge(head1, head2) prev.next = merged while prev.next: prev = prev.next curr = succ subLength <<= 1 return dummyHead.next
def recur(node): if not node: return if node in visited: return visited[node] new_node = ListNode(node.value, True) visited[node] = new_node new_node.next = recur(node.next) new_node.random = recur(node.random) return new_node
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode: dummy_head = ListNode(-1) dummy_head.next = head third_place = dummy_head first_place, second_place = head, head for _ in range(n): first_place = first_place.next while first_place: first_place, second_place, third_place = first_place.next, second_place.next, third_place.next third_place.next = second_place.next return dummy_head.next
def reverseBetween2(self, head: ListNode, left: int, right: int) -> ListNode: dummy_head = ListNode(-1) dummy_head.next = head pre = dummy_head for _ in range(left - 1): pre = pre.next cur = pre.next for _ in range(right - left): next = cur.next cur.next, next.next, pre.next = next.next, pre.next, next return dummy_head.next
def isPalindrome2(self, head: ListNode) -> bool: if not head: return dummy_head = ListNode(-1) cur = head dummy_head.next = head pre = dummy_head while cur: cur.pre = pre cur, pre = cur.next, pre.next foot = pre while head: if head.val != foot.val: return False head, foot = head.next, foot.pre return True
def swapPairs0(self, head: ListNode) -> ListNode: # 迭代 dummyHead = ListNode(-1) dummyHead.next = head cur_node = dummyHead while cur_node.next and cur_node.next.next: node1 = cur_node.next node2 = cur_node.next.next # cur_node.next = node2 # node1.next = node2.next # node2.next = node1 cur_node.next, node1.next, node2.next = node2, node2.next, node1 cur_node = node1 return dummyHead.next
def deleteDuplicates(self, head: ListNode) -> ListNode: dummy_head = ListNode(-1) dummy_head.next = head pre, cur = dummy_head, head #时间复杂度O(n) 空间复杂度O(1) while cur and cur.next: if cur.value == cur.next.value: while cur.next and cur.value == cur.next.value: cur.next = cur.next.next pre.next = cur.next else: pre = pre.next cur = cur.next return dummy_head.next
def insertionSortList(self, head: ListNode) -> ListNode: #时间复杂度O(n*n) if not head: return None dummy_head = ListNode(-1) dummy_head.next = head last_sorted = head cur = head.next while cur: if last_sorted.value > cur.value: pre = dummy_head while pre.next.value <= cur.value: pre = pre.next pre.next, cur.next, last_sorted.next = cur, pre.next, cur.next else: last_sorted = last_sorted.next cur = last_sorted.next return dummy_head.next
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode: stack1 = [] stack2 = [] while l1: stack1.append(l1.value) l1 = l1.next while l2: stack2.append(l2.value) l2 = l2.next #时间复杂度O(max(m,n)) 空间复杂度O(n+m) ret = None add = 0 while stack1 or stack2 or add != 0: x = stack1.pop() if stack1 else 0 y = stack2.pop() if stack2 else 0 sum_ret = x + y + add add = sum_ret // 10 node = ListNode(sum_ret % 10) node.next, ret = ret, node return ret
def reverseKGroup(self, head: ListNode, k: int) -> ListNode: # 翻转一个子链表,并且返回新的头与尾 def reverse(head, tail): if not head: return cur = head new_head = tail while cur != tail: cur.next, cur, new_head = new_head, cur.next, cur return new_head, head dummy_head = ListNode(-1) dummy_head.next = head hair = dummy_head while head: foot = hair for _ in range(k): foot = foot.next if not foot: return dummy_head.next tail = foot.next head, foot = reverse(hair.next, tail) hair.next, hair = head, foot return dummy_head.next