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))
