def partition(head, x):
"""
:param head: ListNode
:param x: int
:return: ListNode
"""
if not head or not head.next:
return head
d = ListNode(0)
d.next = head
t = d
while t.next and t.next.val < x:
t = t.next
h = t.next
while h and h.next:
if h.next.val < x:
temp = t.next
t.next = h.next
h.next = h.next.next
t.next.next = temp
t = t.next
else:
h = h.next
return d.next
def removeNthFromEnd(head, n):
'''
:param head:
:param n:
:return:
Given a linked list, remove the nth node from the end of list and return its head.
'''
if n <= 0 or head is None:
return head
list_len = 0
last = head
while last:
list_len += 1
last = last.next
if n > list_len:
return head
steps = list_len - n
s = ListNode(0)
s.next = head
pre = s
current = head
for i in range(steps):
pre = current
current = current.next
pre.next = current.next
return s.next
def insertionSortList(head):
"""
:type head: ListNode
:rtype: ListNode
"""
if not head:
return head
dummy = ListNode(-999999999999)
dummy.next = head
# 'd -> 1, 3, | 2,1,4,5'
p1 = head
p2 = head.next
while p2:
if p2.val < p1.val:
# do the insert
p = p2
p2 = p2.next
p1.next = p2
pp = dummy
while pp.next.val < p.val:
pp = pp.next
p.next = pp.next
pp.next = p
else:
p1 = p2
p2 = p2.next
return dummy.next
def reverse_between(head, m, n):
"""
:param head:
:param m:
:param n:
:return:
"""
if not head or head.next is None:
return head
dummy = ListNode(-1)
dummy.next = head
s = dummy
p = head
counter = 1
while counter < m:
s = s.next
p = p.next
counter += 1
while counter < n:
tmp = s.next
s.next = p.next
p.next = p.next.next
s.next.next = tmp
counter += 1
return dummy.next
def reverse_list_v3(head):
"""
:param head:
:return:
O(n) time, O(1) space
"""
dummy = ListNode(0)
dummy.next = head
new_head = reverse_list_recursive(dummy)[0]
head.next = None
return new_head
def removeElements(head, val):
"""
:param head: ListNode
:param val: int
:return: ListNode
"""
dummy = ListNode(0)
dummy.next = head
prev_ptr = dummy
ptr = head
while ptr:
if ptr.val == val:
prev_ptr.next = ptr.next
else:
prev_ptr = prev_ptr.next
ptr = ptr.next
return dummy.next
def reverse_list(head):
"""
:param head:
:return:
O(n) time, O(1) space
"""
if head is None:
return None
dummy = ListNode(-1)
dummy.next = head
p1, p2, p3 = dummy, head, head.next
while True:
p2.next = p1
p1 = p2
p2 = p3
if p3 is None:
break
p3 = p3.next
head.next = None
return p1
def removeNthFromEndV2(head, n):
dummy = ListNode(0)
dummy.next = head
if head is None or n <= 0:
return head
fast = dummy
slow = dummy
for _ in range(n):
fast = fast.next
if fast is None:
return head
while fast and fast.next:
fast = fast.next
slow = slow.next
slow.next = slow.next.next
return dummy.next
self.assertTrue(ListNode.equal(
deleteDuplicateFromSortedList(ListNode.build_from_array([])),
ListNode.build_from_array([])))
def test2(self):
self.assertTrue(ListNode.equal(
deleteDuplicateFromSortedListV2(ListNode.build_from_array([1, 1])),
ListNode.build_from_array([])))
self.assertTrue(ListNode.equal(
deleteDuplicateFromSortedListV2(ListNode.build_from_array([1])),
ListNode.build_from_array([1])))
self.assertTrue(ListNode.equal(
deleteDuplicateFromSortedListV2(ListNode.build_from_array([1, 1, 2, 3, 3, 3])),
ListNode.build_from_array([2])))
self.assertTrue(ListNode.equal(
deleteDuplicateFromSortedListV2(ListNode.build_from_array([])),
ListNode.build_from_array([])))
self.assertTrue(ListNode.equal(
deleteDuplicateFromSortedListV2(ListNode.build_from_array([1, 2, 3, 3, 4, 4, 5])),
ListNode.build_from_array([1, 2, 5])))
if __name__ == '__main__':
h0 = ListNode.build_from_array([1, 1])
h1 = deleteDuplicateFromSortedListV2(h0)
h1.traverse()
def test(self):
self.assertTrue(ListNode.equal(
removeNthFromEnd(ListNode.build_from_array([1, 2, 3, 4]), 0),
ListNode.build_from_array([1, 2, 3, 4])))
self.assertTrue(ListNode.equal(
removeNthFromEnd(ListNode.build_from_array([1, 2, 3, 4]), 1),
ListNode.build_from_array([1, 2, 3])))
self.assertTrue(ListNode.equal(
removeNthFromEnd(ListNode.build_from_array([1, 2, 3, 4]), 2),
ListNode.build_from_array([1, 2, 4])))
self.assertTrue(ListNode.equal(
removeNthFromEnd(ListNode.build_from_array([1, 2, 3, 4]), 3),
ListNode.build_from_array([1, 3, 4])))
self.assertTrue(ListNode.equal(
removeNthFromEnd(ListNode.build_from_array([1, 2, 3, 4]), 4),
ListNode.build_from_array([2, 3, 4])))
self.assertTrue(ListNode.equal(
removeNthFromEnd(ListNode.build_from_array([1, 2, 3, 4]), 5),
ListNode.build_from_array([1, 2, 3, 4])))
self.assertTrue(ListNode.equal(
removeNthFromEndV2(ListNode.build_from_array([1, 2, 3, 4]), 0),
ListNode.build_from_array([1, 2, 3, 4])))
self.assertTrue(ListNode.equal(
removeNthFromEndV2(ListNode.build_from_array([1, 2, 3, 4]), 1),
ListNode.build_from_array([1, 2, 3])))
self.assertTrue(ListNode.equal(
removeNthFromEndV2(ListNode.build_from_array([1, 2, 3, 4]), 2),
ListNode.build_from_array([1, 2, 4])))
self.assertTrue(ListNode.equal(
removeNthFromEndV2(ListNode.build_from_array([1, 2, 3, 4]), 3),
ListNode.build_from_array([1, 3, 4])))
self.assertTrue(ListNode.equal(
removeNthFromEndV2(ListNode.build_from_array([1, 2, 3, 4]), 4),
ListNode.build_from_array([2, 3, 4])))
self.assertTrue(ListNode.equal(
removeNthFromEndV2(ListNode.build_from_array([1, 2, 3, 4]), 5),
ListNode.build_from_array([1, 2, 3, 4])))
while h and h.next:
if h.next.val < x:
temp = t.next
t.next = h.next
h.next = h.next.next
t.next.next = temp
t = t.next
else:
h = h.next
return d.next
if __name__ == '__main__':
h0 = ListNode.build_from_array([1, 4, 3, 2, 5, 2])
h0 = partition(h0, 3)
h0.traverse()
h1 = ListNode.build_from_array([1, 1, 1, 1, 0, 0, 0])
h1 = partition(h1, 1)
h1.traverse()
h2 = ListNode.build_from_array([2, 3, 4, 5, 6])
h2 = partition(h2, 1)
h2.traverse()
h3 = ListNode.build_from_array([1])
h3 = partition(h3, 3)
h3.traverse()
Write a function to delete a node (except the tail) in a singly linked list, given only access to that node.
Supposed the linked list is 1 -> 2 -> 3 -> 4 and you are given the third node with value 3, the linked list
should become 1 -> 2 -> 4 after calling your function.
"""
from llinkedList.ListNode import ListNode
def delete_node(node):
"""
:param node: ListNode
:return: void
really fancy....
"""
head, tail = node.next, node
while True:
tail.val = head.val
head = head.next
if head is None:
break
tail = tail.next
tail.next = None
if __name__ == '__main__':
l = ListNode.build_from_array([1, 2, 3, 4])
delete_node(l)
l.traverse()
dummy = ListNode(-999999999999)
dummy.next = head
# 'd -> 1, 3, | 2,1,4,5'
p1 = head
p2 = head.next
while p2:
if p2.val < p1.val:
# do the insert
p = p2
p2 = p2.next
p1.next = p2
pp = dummy
while pp.next.val < p.val:
pp = pp.next
p.next = pp.next
pp.next = p
else:
p1 = p2
p2 = p2.next
return dummy.next
if __name__ == '__main__':
l0 = ListNode.build_from_array([1,2,-3])
print(ListNode.traverse(insertionSortList(l0)))
:return:
"""
if depth <= 1:
return root
mid = depth // 2
counter = 1
pointer = root
while counter < mid:
pointer = pointer.right
counter += 1
new_root = pointer.right
pointer.right = None
new_root.left = balance(root, mid)
new_root.right = balance(new_root.right, depth - mid - 1)
return new_root
from llinkedList.ListNode import ListNode
if __name__ == '__main__':
h0 = ListNode.build_from_array([1, 2, 3, 4, 5, 6, 7])
r0 = TreeNode(-1)
d0 = linkedList2SkewTree(h0, r0)
r00 = balance(r0.right, d0)
TreeNode.traverse(r00)
def test2(self):
self.assertTrue(ListNode.equal(
deleteDuplicateFromSortedListV2(ListNode.build_from_array([1, 1])),
ListNode.build_from_array([])))
self.assertTrue(ListNode.equal(
deleteDuplicateFromSortedListV2(ListNode.build_from_array([1])),
ListNode.build_from_array([1])))
self.assertTrue(ListNode.equal(
deleteDuplicateFromSortedListV2(ListNode.build_from_array([1, 1, 2, 3, 3, 3])),
ListNode.build_from_array([2])))
self.assertTrue(ListNode.equal(
deleteDuplicateFromSortedListV2(ListNode.build_from_array([])),
ListNode.build_from_array([])))
self.assertTrue(ListNode.equal(
deleteDuplicateFromSortedListV2(ListNode.build_from_array([1, 2, 3, 3, 4, 4, 5])),
ListNode.build_from_array([1, 2, 5])))
s = dummy
p = head
counter = 1
while counter < m:
s = s.next
p = p.next
counter += 1
while counter < n:
tmp = s.next
s.next = p.next
p.next = p.next.next
s.next.next = tmp
counter += 1
return dummy.next
if __name__ == '__main__':
h0 = ListNode.build_from_array([1, 2, 3, 4, 5])
ListNode.traverse(reverse_between(h0, 2, 4))
h0 = ListNode.build_from_array([1, 2, 3, 4, 5])
ListNode.traverse(reverse_between(h0, 1, 5))
h0 = ListNode.build_from_array([1])
ListNode.traverse(reverse_between(h0, 1, 1))
:param head: ListNode
:return: ListNode
"""
if head is None:
return None
if head.next is None:
return head
p1, p2 = head, head.next
tail = swap_pairs(head.next.next)
p1.next = tail
p2.next = p1
return p2
if __name__ == '__main__':
l0 = ListNode.build_from_array([1, 2, 3, 4])
h0 = swap_pairs(l0)
h0.traverse()
l1 = ListNode.build_from_array([])
h1 = swap_pairs(l1)
print(h1)
l2 = ListNode.build_from_array([1, 2, 3])
h2 = swap_pairs(l2)
h2.traverse()
def test(self):
self.assertTrue(ListNode.equal(
mergeTwoSortedList(ListNode.build_from_array([1]), ListNode.build_from_array([1])),
ListNode.build_from_array([1, 1])
))
self.assertTrue(ListNode.equal(
mergeTwoSortedList(ListNode.build_from_array([]), ListNode.build_from_array([])),
ListNode.build_from_array([])
))
self.assertTrue(ListNode.equal(
mergeTwoSortedList(ListNode.build_from_array([1, 3, 6]), ListNode.build_from_array([2, 4, 5])),
ListNode.build_from_array([1, 2, 3, 4, 5, 6])
))
self.assertTrue(ListNode.equal(
mergeTwoSortedList(ListNode.build_from_array([1]), ListNode.build_from_array([2, 4, 5])),
ListNode.build_from_array([1, 2, 4, 5])
))
carry = 0
if val >= 10:
val -= 10
carry = 1
node = ListNode(val)
last.next = node
last = node
l2 = l2.next
if carry == 1:
node = ListNode(1)
last.next = node
head.traverse()
return head
if __name__ == '__main__':
l1 = ListNode.build_from_array([2, 4, 3])
l2 = ListNode.build_from_array([2, 4, 3])
ListNode.add_two_numbers(l1, l2)
l1 = ListNode.build_from_array([5])
l2 = ListNode.build_from_array([5])
ListNode.add_two_numbers(l1, l2)
l1 = ListNode.build_from_array([1])
l2 = ListNode.build_from_array([9, 8])
ListNode.add_two_numbers(l1, l2)
def merge(l1, l2):
dummy = ListNode(-1)
p = dummy
while l1 and l2:
if l1.val < l2.val:
p.next = l1
l1 = l1.next
else:
p.next = l2
l2 = l2.next
p = p.next
if l1:
p.next = l1
l1 = l1.next
p = p.next
if l2:
p.next = l2
l2 = l2.next
p = p.next
return dummy.next
if __name__ == '__main__':
l0 = ListNode.build_from_array([1, 2, 3, 4, -5, -6])
ListNode.traverse(sortList(l0))
steps = size // 2
p1 = head
while True:
steps -= 1
if steps == 0:
break
p1 = p1.next
p2 = p1.next
if size % 2 != 0:
p2 = p2.next
p1.next = None
new_head = reverse_list(head)
while p2:
if p2.val != new_head.val:
return False
p2 = p2.next
new_head = new_head.next
return True
if __name__ == '__main__':
head1 = ListNode.build_from_array([1, 2, 3, 2, 1, 1])
head2 = ListNode.build_from_array([1, 2, 3, 3, 2, 1])
head3 = ListNode.build_from_array([1])
head4 = ListNode.build_from_array([])
print(isPalindromV2(head1))
print(isPalindromV2(head2))
print(isPalindromV2(head3))
print(isPalindromV2(head4))
dummy = ListNode(0)
dummy.next = head
new_head = reverse_list_recursive(dummy)[0]
head.next = None
return new_head
def reverse_list_recursive(head):
"""
:param head: ListNode not None
:return: (ListNode, ListNode)
"""
if head.next is None:
return head, head
head1, tail1 = reverse_list_recursive(head.next)
tail1.next = head
return head1, head
if __name__ == '__main__':
head = ListNode.build_from_array([1, 2, 3])
head.traverse()
tail = reverseList(head)
tail.traverse()
head = reverse_list(tail)
head.traverse()
tail = reverse_list(head)
tail.traverse()
