def main():
head = ListNode.array2list([1,2,2,1,1])
print Solution().isPalindrome(head)
head.trace()
print Solution()._find_middle(head)
h = Solution._reverse(ListNode.array2list([1,2,3,4,5]))
h.trace()
def main():
head = ListNode.array2list([1, 2, 2, 1, 1])
print Solution().isPalindrome(head)
head.trace()
print Solution()._find_middle(head)
h = Solution._reverse(ListNode.array2list([1, 2, 3, 4, 5]))
h.trace()
def reverseKGroup_Iter(head, k):
dmy = ListNode(-1)
dmy.next = head
tmp_pre = dmy
while (head):
tail = head
cnt = 0
while (tail and cnt < k):
tail = tail.next
cnt += 1
if cnt < k:
tmp_pre.next = head
head = tail
else:
pre = head
while (cnt > 0):
tmp = head.next
head.next = tail
tail = head
head = tmp
cnt -= 1
tmp_pre.next = tail
tmp_pre = pre
return dmy.next
def main():
root1, root2 = ListNode(0), ListNode(0)
root1.append([1])
root2.append([9, 9, 9, 5, 2, 5, 3])
sum_node1 = sum_lists_post_order(root1, root2)
sum_node2 = sum_lists_pre_order(root1, root2)
print(f"{root1} + {root2} = {sum_node1}")
print(sum_node2)
def createLL(n):
head = None
i = n
while (i > 0):
tmp = ListNode(i)
tmp.next = head
head = tmp
i -= 1
return head
def main():
root = ListNode(0)
root.append([1, 3, 5, 7, 9])
point = root
while point.val != 3:
point = point.next
print(root)
print(point)
remove_node(point)
print(root)
def remove_duplicate_node(root: ListNode):
pre = ListNode(0)
memo = set()
pre.next = root
point = pre
while point.next:
if point.next.val not in memo:
memo.add(point.next.val)
point = point.next
else:
point.next = point.next.next
def partition(root: ListNode, part_num: int):
left, right = ListNode("l"), ListNode("r")
left.next = root
point1, point2 = left, right
while point1.next:
node = point1.next
if node.val >= part_num:
point1.next = node.next
node.next = None
point2.next = node
point2 = point2.next
else:
point1 = point1.next
point1.next = right.next
def remove_duplicate_node_without_extra_memory(root: ListNode):
pre = ListNode(0)
pre.next = root
point = pre
while point.next:
point0 = root
flag = False
while point0 != point.next:
if point0.val == point.next.val:
flag = True
point.next = point.next.next
break
point0 = point0.next
if not flag:
point = point.next
def test_partition_list():
head = ListNode.array2list([1,4,3,2,5,2])
head.trace()
s = Solution()
ret = s.partition(None, 0)
if ret:
ret.trace()
def test_partition_list():
head = ListNode.array2list([1, 4, 3, 2, 5, 2])
head.trace()
s = Solution()
ret = s.partition(None, 0)
if ret:
ret.trace()
def main():
root1 = ListNode(1)
root1.append([2, 3, 4, 5, 6])
root2 = ListNode(0)
root2.append([100, 200])
point = root2
while point.next:
point = point.next
point.next = root1
print(find_insertion_node(root1, root2))
def sum_lists_post_order(root1: ListNode, root2: ListNode) -> ListNode:
ans = ListNode(0)
carry = 0
p1, p2, p3 = root1, root2, ans
while p1 or p2 or carry:
val1 = p1.val if p1 else 0
val2 = p2.val if p2 else 0
temp = carry + val1 + val2
carry = temp // 10
temp %= 10
node = ListNode(temp)
p3.next = node
if p1:
p1 = p1.next
if p2:
p2 = p2.next
p3 = p3.next
return ans.next
def test_reverse_list():
head = ListNode.array2list([
1,
2,
3,
])
head.trace()
head = Solution().reverseList(None)
if head:
head.trace()
def test_circle_detect():
head = ListNode.array2list([1,2,3,4])
node = head
while node:
if not node.next:
break
node = node.next
node.next = head
ret = Solution().detectCycle(head)
if ret:
print ret.val
def test_circle_detect():
head = ListNode.array2list([1, 2, 3, 4])
node = head
while node:
if not node.next:
break
node = node.next
node.next = head
ret = Solution().detectCycle(head)
if ret:
print ret.val
def addTwoNumbers(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
reslist, head = None, None
carry = 0
while l1 or l2:
x = l1.val if l1 else 0
y = l2.val if l2 else 0
res = x + y + carry
carry = res // 10
if reslist is None:
reslist = ListNode(res % 10)
head = reslist
else:
reslist.next = ListNode(res % 10)
reslist = reslist.next
if l1:
l1 = l1.next
if l2:
l2 = l2.next
if carry != 0:
reslist.next = ListNode(carry)
return head
def test_rotate_right():
head = ListNode.array2list([1, 2, 3, 4])
head.trace()
head = Solution().rotateRight(head, 5)
if head:
head.trace()
def test_rotate_right():
head = ListNode.array2list([1,2,3,4])
head.trace()
head = Solution().rotateRight(head, 5)
if head:
head.trace()
def insert_first_node(root: ListNode, val) -> ListNode:
node = ListNode(val)
node.next = root
return node
def remove_node(node: ListNode):
if node.next is None:
return False
node.val = node.next.val
node.next = node.next.next
def main():
root = ListNode(0)
root.append([10, 20, 30, 4, 5, 6, 7, 8])
print(root)
partition(root, 8)
print(root)
def main():
list1 = ListNode(0)
list2 = ListNode(1)
list3 = ListNode(1)
list1.append([1, 2, 3])
list2.append([2, 3, 4, 5, 4, 3, 2, 1])
list3.append([1])
print(is_palindrome(list1), is_palindrome(list2), is_palindrome(list3))
def main():
head = ListNode.array2list([1, 2, 3, 4])
t = head.next
Solution().deleteNode(t)
head.trace()
def main():
root = ListNode(0)
root.append([1, 2, 3, 4, 5, 5, 6, 7, 8, 8, 8, 8])
print(root)
remove_duplicate_node_without_extra_memory(root)
print(root)
def main():
head = ListNode.array2list([1,2,3,4])
t = head.next
Solution().deleteNode(t)
head.trace()
def test_reverse_list():
head = ListNode.array2list([1,2,3,])
head.trace()
head = Solution().reverseList(None)
if head:
head.trace()
def main():
root = ListNode(0)
root.append([1, 3, 4, 5, 6])
print(kth_last_node(root, 6))
