def rotateRight(head: ListNode, k: int) -> ListNode: p = ListNode("NULL", head) if not p.next or not p.next.next: return p.next if not p.next.next.next: k = k % 2 if k == 0: return p.next else: p.next.next.next = p.next p.next = p.next.next p.next.next.next = None return p.next node_pointer1 = p.next length = 1 while node_pointer1.next: length += 1 node_pointer1 = node_pointer1.next k = k % length if k == 0: return p.next else: node_pointer2 = p.next for i in range(length - 1, k, -1): node_pointer2 = node_pointer2.next node_pointer1.next = p.next p.next = node_pointer2.next node_pointer2.next = None return p.next
def reverse(node: ListNode) -> None: pre = None cur = node.next la = cur.next node.next = None while cur: cur.next = pre pre = cur cur = la if la: la = la.next node.next = pre
def removeElements(head: ListNode, val: int) -> ListNode: node_pointer = list_node = ListNode("NULL", ListNode("NULL", head)) while node_pointer.next: if not node_pointer.next.next: if node_pointer.next.val == val: node_pointer.next = None break if node_pointer.next.val == val: node_pointer.next = node_pointer.next.next continue if node_pointer.next: node_pointer = node_pointer.next return list_node.next.next
def deleteDuplicates(head: ListNode) -> ListNode or None: val = [] p = ListNode("NULL", head) pointer = p while pointer.next: pointer = pointer.next val.append(pointer.val) dic = sorted(set(val)) p.next = None pointer = p for num in dic: pointer.next = ListNode(num) pointer = pointer.next return p.next
def detectCycle(head: ListNode) -> ListNode or None: def getCycleSize() -> int: dummy = ListNode("NULL", head) slow = fast = dummy count = 0 while fast.next: for i in range(0, 2): if fast.next == slow: count = 1 slow = fast.next while slow != fast: slow = slow.next count += 1 return count if fast.next: fast = fast.next else: return count slow = slow.next return count size = getCycleSize() if size > 0: p = ListNode("NULL", head) pre = p for j in range(0, size): pre = pre.next last = p.next while pre.next != last: last = last.next pre = pre.next return last
def reverseKGroup(head: ListNode, k: int) -> ListNode: def hasKNext(cur_pointer: ListNode) -> bool: pointer = cur_pointer for i in range(0, k + 1): if pointer: pointer = pointer.next else: return False return True # 在hasKNext()为True的范围里使用 def nextSNode(cur_pointer: ListNode, step: int) -> ListNode: pointer = cur_pointer for i in range(0, step): pointer = pointer.next return pointer p = ListNode("NULL", head) last_pointer = p while hasKNext(last_pointer): pre_pointer = nextSNode(last_pointer, k + 1) new_first = nextSNode(last_pointer, k) for j in range(k - 1, 0, -1): node_pointer = nextSNode(last_pointer, j) node_pointer.next.next = node_pointer last_pointer.next.next = pre_pointer last_pointer.next = new_first last_pointer = nextSNode(last_pointer, k) return p.next
def deleteDuplicates(head: ListNode) -> ListNode or None: q = ListNode("NULL", head) val = {} pointer = q while pointer.next: pointer = pointer.next if pointer.val not in val.keys(): val.update({pointer.val: 1}) else: val[pointer.val] += 1 q.next = None pointer = q for num in val.keys(): if val[num] == 1: pointer.next = ListNode(num) pointer = pointer.next return q.next
def middleNode(head: ListNode) -> ListNode: dummy = ListNode("NULL", head) s = fast = dummy while fast: for i in range(0, 2): if fast: fast = fast.next s = s.next return s
def findMidNode(head2: ListNode) -> ListNode or None: dummy = ListNode("NULL", head2) slow = fast = dummy while fast: for i in range(0, 2): fast = fast.next if not fast: break slow = slow.next return slow
def midNode() -> ListNode: dummy1 = ListNode("NULL", head) fast = slow = dummy1 if dummy1.next: while fast.next: for i in range(0, 2): if fast.next: fast = fast.next slow = slow.next return slow
def addTwoNumbers(l1: ListNode, l2: ListNode) -> ListNode: def listSum(node: ListNode) -> int: p = node tmp = [] result = 0 while p: tmp.append(p.val) p = p.next for i in range(1, len(tmp) + 1): result += tmp[-i] * 10**(i - 1) return result the_sum = listSum(l1) + listSum(l2) length = len(str(the_sum)) node_pointer = l3 = ListNode("NULL") for j in range(length, 0, -1): node_pointer.next = ListNode(the_sum // (10**(j - 1))) the_sum -= node_pointer.next.val * 10**(j - 1) node_pointer = node_pointer.next return l3.next
def deleteDuplicates(head: ListNode) -> ListNode: q = ListNode("NULL", head) node_pointer = q if node_pointer.next: node_pointer = node_pointer.next while node_pointer.next: while node_pointer.next and node_pointer.next.val == node_pointer.val: node_pointer.next = node_pointer.next.next if node_pointer.next: node_pointer = node_pointer.next return q.next
def deleteDuplicates(head: ListNode) -> ListNode: q = ListNode("NULL", head) pre = q.next if pre: while pre.next: last = pre.next while last and last.val == pre.val: last = last.next pre.next = last if last: pre = last return q.next
def addTwoNumbers(l1: ListNode, l2: ListNode) -> ListNode: def pushInStack(node: ListNode) -> List[int]: p = node result = [] while p: result.append(p.val) p = p.next return result list1 = pushInStack(l1) list2 = pushInStack(l2) l3 = ListNode("NULL") carry = 0 while True: the_sum = 0 if list1: the_sum += list1.pop() if list2: the_sum += list2.pop() the_sum += carry if the_sum > 9: carry = 1 else: carry = 0 if not l3.next: l3.next = ListNode(the_sum % 10) else: new_pointer = ListNode(the_sum % 10, l3.next) l3.next = new_pointer if not list1 and not list2 and carry == 0: break return l3.next
def hasCycle(head: ListNode) -> bool: dummy = ListNode("NULL", head) slow = fast = dummy while fast.next: for i in range(0, 2): if fast.next == slow: return True if fast.next: fast = fast.next else: return False slow = slow.next return False
def getIntersectionNode(head_a: ListNode, head_b: ListNode) -> ListNode or None: dummy1 = ListNode("NULL", head_a) dummy2 = ListNode("NULL", head_b) if head_a and head_b: pa = dummy1 pb = dummy2 count = 0 flag = 0 while pa.next or pb.next: while pa.next and pb.next: pa = pa.next pb = pb.next if not pa.next: flag = 1 if not pb.next: flag = 2 if not pa.next and not pb.next: if pa != pb: return else: break if pa.next: pa = pa.next if pb.next: pb = pb.next count += 1 pa = dummy1 pb = dummy2 for i in range(0, count): if flag == 1: pb = pb.next else: pa = pa.next while pa != pb: pa = pa.next pb = pb.next return pa
def isPalindrome(head: ListNode) -> bool: tmp = deque([]) dummy = ListNode("NULL", head) node_pointer = dummy count = 1 while node_pointer.next: tmp.append((node_pointer.next.val, count)) node_pointer = node_pointer.next count += 1 while len(tmp) >= 2: if tmp[-1][0] == tmp[0][0]: tmp.popleft() tmp.pop() else: break return not tmp or (len(tmp) == 1 and tmp[0][1] == math.ceil(count / 2))
def swapPairs(head: ListNode or None) -> ListNode: if not head: return head p = ListNode("NULL", head) node_pointer1 = p while node_pointer1.next.next: node_pointer2 = node_pointer1.next.next.next node_pointer3 = node_pointer1.next.next node_pointer3.next = node_pointer1.next node_pointer1.next.next = node_pointer2 node_pointer1.next = node_pointer3 if node_pointer2 and node_pointer2.next: node_pointer1 = node_pointer1.next.next else: break return p.next
def mergeTwoLists(l1: ListNode, l2: ListNode) -> ListNode: node_pointer1 = l1 node_pointer2 = l2 l3 = node_pointer3 = ListNode("NULL") while node_pointer1 or node_pointer2: if not l2: l1 = l1.next node_pointer3.next = node_pointer1 node_pointer1.next = None node_pointer1 = l1 node_pointer3 = node_pointer3.next continue if not l1: l2 = l2.next node_pointer3.next = node_pointer2 node_pointer2.next = None node_pointer2 = l2 node_pointer3 = node_pointer3.next continue if type(node_pointer1.val) is str: l1 = l1.next node_pointer3.next = node_pointer1 node_pointer1.next = None node_pointer1 = l1 node_pointer3 = node_pointer3.next continue if type(node_pointer2.val) is str: l2 = l2.next node_pointer3.next = node_pointer2 node_pointer2.next = None node_pointer2 = l2 node_pointer3 = node_pointer3.next continue if node_pointer1.val < node_pointer2.val: l1 = l1.next node_pointer3.next = node_pointer1 node_pointer1.next = None node_pointer1 = l1 else: l2 = l2.next node_pointer3.next = node_pointer2 node_pointer2.next = None node_pointer2 = l2 node_pointer3 = node_pointer3.next return l3.next
def getCycleSize() -> int: dummy = ListNode("NULL", head) slow = fast = dummy count = 0 while fast.next: for i in range(0, 2): if fast.next == slow: count = 1 slow = fast.next while slow != fast: slow = slow.next count += 1 return count if fast.next: fast = fast.next else: return count slow = slow.next return count
def reorderList(head: ListNode) -> None: # 正确,但是超时 dummy = ListNode("NULL", head) last = front = dummy if dummy.next and dummy.next.next: while last.next: last = last.next tmp = front.next front = tmp while front != last and front.next != last: while tmp.next != last: tmp = tmp.next last.next = front.next tmp.next = None front.next = last last = tmp front = front.next tmp = front.next front = tmp
def reverseBetween(head: ListNode, m: int, n: int) -> ListNode: dummy = ListNode("NULL", head) tmp_f = dummy for i in range(0, m - 1): tmp_f = tmp_f.next tmp_l = tmp_f for i in range(0, n - m + 2): tmp_l = tmp_l.next pre = None n_last = cur = tmp_f.next last = cur.next for i in range(0, n - m + 1): cur.next = pre pre = cur cur = last if last: last = last.next n_last.next = tmp_l tmp_f.next = pre return dummy.next
def isPalindrome(head: ListNode) -> bool: # False tmp = {} dummy = ListNode("NULL", head) node_pointer = dummy while node_pointer.next: if node_pointer.next.val not in tmp.keys(): tmp.update({node_pointer.next.val: 1}) else: tmp[node_pointer.next.val] += 1 node_pointer = node_pointer.next for num in tmp.keys(): tmp[num] %= 2 flag = 0 for num in tmp.keys(): if tmp[num] != 0 and flag == 0: flag = 1 elif tmp[num] != 0 and flag == 1: return False return True
def reorderList(head: ListNode) -> None: def midNode() -> ListNode: dummy1 = ListNode("NULL", head) fast = slow = dummy1 if dummy1.next: while fast.next: for i in range(0, 2): if fast.next: fast = fast.next slow = slow.next return slow def reverse(node: ListNode) -> None: pre = None cur = node.next la = cur.next node.next = None while cur: cur.next = pre pre = cur cur = la if la: la = la.next node.next = pre dummy = ListNode("NULL", head) front = dummy if dummy.next and dummy.next.next: front = front.next last = midNode() reverse(last) last = last.next tmp = front while tmp.next != last: tmp = tmp.next while last and front != tmp: tmp.next = last.next last.next = front.next front.next = last front = last.next last = tmp.next
def deleteDuplicates(head: ListNode) -> ListNode: q = ListNode("NULL", head) pre = q count = 0 last = pre.next if last: val = last.val while last: if last.val == val and count < 2: count += 1 elif last.val != val and count == 2: val = last.val count = 1 pre.next = last elif last.val != val and count < 2: val = last.val pre = pre.next last = last.next if count == 2: pre.next = last return q.next
end_a = fa fa = head_b flag = 1 elif fa != end_a: return else: fa = head_b if sa.next: sa = sa.next else: sa = head_b return sa cycle_p = getFirstMeeting() if cycle_p: list_p = head_a while cycle_p != list_p: if cycle_p.next: cycle_p = cycle_p.next else: cycle_p = head_b list_p = list_p.next return cycle_p if __name__ == "__main__": cross = ListNode(7, ListNode(8, ListNode(9, ListNode(10)))) list1 = ListNode(1, ListNode(2, ListNode(3, ListNode(4, cross)))) list2 = ListNode(5, ListNode(6, cross)) print(getIntersectionNode(list1, list2))
""" # Definition for singly-linked list. from DSAA.data_structure.basic.LeetcodeNode import ListNode def removeElements(head: ListNode, val: int) -> ListNode: node_pointer = list_node = ListNode("NULL", ListNode("NULL", head)) while node_pointer.next: if not node_pointer.next.next: if node_pointer.next.val == val: node_pointer.next = None break if node_pointer.next.val == val: node_pointer.next = node_pointer.next.next continue if node_pointer.next: node_pointer = node_pointer.next return list_node.next.next if __name__ == "__main__": l1 = ListNode( 1, ListNode(2, ListNode(6, ListNode(5, ListNode(9, ListNode(6)))))) print(l1) print(removeElements(l1, 6)) l2 = ListNode(1, ListNode(1)) print(l2) print(removeElements(l2, 1))
def deleteDuplicates(head: ListNode) -> ListNode: q = ListNode("NULL", head) node_pointer = q if node_pointer.next: node_pointer = node_pointer.next while node_pointer.next: while node_pointer.next and node_pointer.next.val == node_pointer.val: node_pointer.next = node_pointer.next.next if node_pointer.next: node_pointer = node_pointer.next return q.next if __name__ == "__main__": test = ListNode( 1, ListNode(1, ListNode(1, ListNode(2, ListNode(2, ListNode(3)))))) print(deleteDuplicates(test)) test2 = ListNode( 1, ListNode( 1, ListNode( 1, ListNode( 1, ListNode( 2, ListNode( 2, ListNode( 3,
if pointer: pointer = pointer.next else: return False return True # 在hasKNext()为True的范围里使用 def nextSNode(cur_pointer: ListNode, step: int) -> ListNode: pointer = cur_pointer for i in range(0, step): pointer = pointer.next return pointer p = ListNode("NULL", head) last_pointer = p while hasKNext(last_pointer): pre_pointer = nextSNode(last_pointer, k + 1) new_first = nextSNode(last_pointer, k) for j in range(k - 1, 0, -1): node_pointer = nextSNode(last_pointer, j) node_pointer.next.next = node_pointer last_pointer.next.next = pre_pointer last_pointer.next = new_first last_pointer = nextSNode(last_pointer, k) return p.next if __name__ == "__main__": test = ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5))))) print(reverseKGroup(test, 2))
# Definition for singly-linked list. from DSAA.data_structure.basic.LeetcodeNode import ListNode def addTwoNumbers(l1: ListNode, l2: ListNode) -> ListNode: def listSum(node: ListNode) -> int: p = node tmp = [] result = 0 while p: tmp.append(p.val) p = p.next for i in range(1, len(tmp) + 1): result += tmp[-i] * 10**(i - 1) return result the_sum = listSum(l1) + listSum(l2) length = len(str(the_sum)) node_pointer = l3 = ListNode("NULL") for j in range(length, 0, -1): node_pointer.next = ListNode(the_sum // (10**(j - 1))) the_sum -= node_pointer.next.val * 10**(j - 1) node_pointer = node_pointer.next return l3.next if __name__ == "__main__": q1 = ListNode(1, ListNode(2, ListNode(3))) q2 = ListNode(1, ListNode(2, ListNode(3, ListNode(4)))) print(addTwoNumbers(q1, q2))