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