from linked_list import LinkedList, print_list
def even_list(head):
prev = head
cur = head.next
while cur and cur.next:
tmp = prev.next
prev.next = cur.next
cur.next = cur.next.next
prev.next.next = tmp
cur = cur.next
prev = prev.next
return head
if __name__ == '__main__':
head = LinkedList(1)
head.next = LinkedList(2)
head.next.next = LinkedList(3)
head.next.next.next = LinkedList(4)
head.next.next.next.next = LinkedList(5)
print_list(even_list(head))
from linked_list import LinkedList, print_list
def merge(l1, l2):
head = l = LinkedList(0)
while l1 and l2:
if l1.value > l2.value:
l.next = LinkedList(l2.value)
l2 = l2.next
else:
l.next = LinkedList(l1.value)
l1 = l1.next
l = l.next
if l1:
l.next = l1
if l2:
l.next = l2
return head.next
if __name__ == '__main__':
l1 = LinkedList(1)
l1.next = LinkedList(2)
l1.next.next = LinkedList(4)
l2 = LinkedList(1)
l2.next = LinkedList(3)
l2.next.next = LinkedList(4)
print_list(merge(l1, l2))
#!/bin/python
from linked_list import create_list, print_list, print_separator, N, get_random_middle, get_last, visit_list
def get_instersection(root_1, root_2):
visit_list(root_1)
node = root_2
while node and not node.visited:
node.visited
node = node.next
return node
print "LOOP DETECTION"
root_1 = create_list(N)
root_2 = create_list(N)
random_node = get_random_middle(root_1, N)
last_node_2 = get_last(root_2)
last_node_2.next = random_node
print print_list(root_1)
print print_list(root_2)
intersect = get_instersection(root_1, root_2)
if intersect:
print intersect.value
else:
print "None"
print_separator()
return (head, tail)
def partition(root, x):
head = head_tail = tail = tail_tail = None
node = root
while node:
if node.value < x:
head, head_tail = update_list(head, head_tail, node)
else:
tail, tail_tail = update_list(tail, tail_tail, node)
node = node.next
# Remove tail cycle
if tail: tail_tail.next = None
# Merge head and tail
if head: head_tail.next = tail
else: head = tail
# Exist
return head
print "PARTITION"
x = 50
root = create_list(N)
print print_list(root)
root = partition(root, x)
print print_list(root)
print_separator()
import linked_list as ll import test_utils as tu from q05_merge_sorted import merge_sorted for len_1, len_2 in [(6, 6), (1, 1), (3, 3), (6, 9), (1, 3), (0, 5)]: l1 = tu.gen_list_of_len(len_1) ll.print_list(l1) l2 = tu.gen_list_of_len(len_2) ll.print_list(l2) ll.print_list(merge_sorted(l1, l2))
from tree import TreeNode
from linked_list import LinkedList, print_list
def tree_to_list(root):
if not root:
return root
new_head = head = LinkedList(root.value)
right = tree_to_list(root.right)
head.next = tree_to_list(root.left)
while head.next:
head = head.next
head.next = right
return new_head
if __name__ == '__main__':
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(5)
root.left.left = TreeNode(3)
root.left.right = TreeNode(4)
root.right.right = TreeNode(6)
print_list(tree_to_list(root))
from linked_list import LinkedList, print_list
def add_two_numbers(num1, num2):
carry = 0
head = result = LinkedList(0)
while num1 or num2 or carry != 0:
a = 0 if num1 is None else num1.value
b = 0 if num2 is None else num2.value
sum = a + b + carry
result.next = LinkedList(sum % 10)
carry = sum / 10
result = result.next
num1 = num1.next if num1 is not None else None
num2 = num2.next if num2 is not None else None
return head.next
if __name__ == '__main__':
root1 = LinkedList(2)
root1.next = LinkedList(4)
root1.next.next = LinkedList(3)
root2 = LinkedList(5)
root2.next = LinkedList(6)
root2.next.next = LinkedList(4)
print_list(add_two_numbers(root1, root2))
from linked_list import LinkedList, print_list
def remove_element(l, val):
head = LinkedList(0)
head.next = l
res = head.next
while head and head.next:
if head.next.value == val:
head.next = head.next.next
else:
head = head.next
return res
if __name__ == '__main__':
head = LinkedList(1)
head.next = LinkedList(2)
head.next.next = LinkedList(6)
head.next.next.next = LinkedList(3)
head.next.next.next.next = LinkedList(5)
head.next.next.next.next.next = LinkedList(6)
print_list(remove_element(head, 6))
from linked_list import LinkedList, print_list
from add_huge_numbers import add_huge_numbers
if __name__ == '__main__':
ll = LinkedList.fromList([9876, 5432, 1999])
ll2 = LinkedList.fromList([1, 8001])
print_list(add_huge_numbers(ll, ll2))
from linked_list import LinkedList, print_list
def remove_nth_from_end(root, n):
head = l1 = l2 = root
for i in range(n):
l2 = l2.next
while l2.next:
l2 = l2.next
l1 = l1.next
l1.next = l1.next.next
return head
if __name__ == '__main__':
root = LinkedList(1)
root.next = LinkedList(2)
root.next.next = LinkedList(3)
root.next.next.next = LinkedList(4)
root.next.next.next.next = LinkedList(5)
print_list(remove_nth_from_end(root, 2))
from linked_list import LinkedList, print_list
import heapq
def merge_k(l):
heap = list()
for _list in l:
while _list:
heapq.heappush(heap, _list.value)
_list = _list.next
head = point = LinkedList(0)
while len(heap):
point.next = LinkedList(heapq.heappop(heap))
point = point.next
return head.next
if __name__ == '__main__':
l1 = LinkedList(1)
l1.next = LinkedList(4)
l1.next.next = LinkedList(5)
l2 = LinkedList(1)
l2.next = LinkedList(3)
l2.next.next = LinkedList(4)
l3 = LinkedList(2)
l3.next = LinkedList(6)
l = [l1, l2, l3]
print_list(merge_k(l))
node = root
num_str = []
while node:
num_str.append(str(node.value))
node = node.next
if not num_str:
num_str = ["0"]
return int("".join(num_str))
def sum_lists_head(root_1, root_2):
num_1 = get_num_head(root_1)
num_2 = get_num_head(root_2)
num_3 = list(str(num_1 + num_2))
return create_list_2(num_3)
root_1 = create_list_2(list(str(716)))
root_2 = create_list_2(list(str(592)))
print print_list(root_1)
print print_list(root_2)
print print_list(sum_lists_tail(root_1, root_2))
print ""
root_1 = create_list_2(list(str(617)))
root_2 = create_list_2(list(str(295)))
print print_list(root_1)
print print_list(root_2)
print print_list(sum_lists_head(root_1, root_2))
def get_num_head(root):
node = root
num_str = []
while node:
num_str.append(str(node.value))
node = node.next
if not num_str:
num_str = ["0"]
return int("".join(num_str))
def sum_lists_head(root_1, root_2):
num_1 = get_num_head(root_1)
num_2 = get_num_head(root_2)
num_3 = list(str(num_1 + num_2))
return create_list_2(num_3)
root_1 = create_list_2(list(str(716)))
root_2 = create_list_2(list(str(592)))
print print_list(root_1)
print print_list(root_2)
print print_list(sum_lists_tail(root_1, root_2))
print ""
root_1 = create_list_2(list(str(617)))
root_2 = create_list_2(list(str(295)))
print print_list(root_1)
print print_list(root_2)
print print_list(sum_lists_head(root_1, root_2))
def reorder(head):
fast = head
slow = head
while fast.next and fast.next.next:
fast = fast.next.next
slow = slow.next
temp = slow.next
slow.next = None
next = reverse(temp)
new_head = LinkedList(0)
curr = new_head
while head or next:
if head:
curr.next = head
curr = curr.next
head = head.next
if next:
curr.next = next
curr = curr.next
next = next.next
return new_head.next
if __name__ == '__main__':
head = LinkedList(1)
head.next = LinkedList(2)
head.next.next = LinkedList(3)
head.next.next.next = LinkedList(4)
head.next.next.next.next = LinkedList(5)
print_list(reorder(head))
count = 0
while cur:
cur = cur.next
count += 1
return count
def rotate_list(l, k):
head = l
cur = prev = l
k = k % length(l)
for _ in range(k):
cur = cur.next
while cur.next:
prev = prev.next
cur = cur.next
new_head = prev.next
cur.next = head
prev.next = None
return new_head
if __name__ == '__main__':
root = LinkedList(1)
root.next = LinkedList(2)
root.next.next = LinkedList(3)
root.next.next.next = LinkedList(4)
root.next.next.next.next = LinkedList(5)
k = 8
print_list(rotate_list(root, k))
#!/bin/python
from linked_list import create_list, print_list, print_separator, N, get_random_middle, get_last
def detect_loop(root):
node = root
prev = None
while not node.visited:
node.visited = True
prev = node
node = node.next
return prev
print "LOOP DETECTION"
root = create_list(N)
random_node = get_random_middle(root, N)
last_node = get_last(root)
last_node.next = random_node
last_loop_node = detect_loop(root)
print "Last Loop Node: {0}".format(last_loop_node.value)
print "First Loop Node: {0}".format(last_loop_node.next.value)
print "Rand Node: {0}".format(random_node.value)
last_node.next = None
print print_list(root)
print_separator()
from linked_list import LinkedList, print_list
def swap(l):
if l is None:
return None
if l.next is None:
return l
next = l.next
next_next = next.next
next.next = l
head = next
l.next = swap(next_next)
return head
if __name__ == '__main__':
l = LinkedList(1)
l.next = LinkedList(2)
l.next.next = LinkedList(3)
l.next.next.next = LinkedList(4)
print_list(swap(l))
from linked_list import LinkedList, print_list
def delete2(head, n):
cur = head
new_head = LinkedList(0)
new_head.next = head
prev = new_head
while cur:
if cur.value == n:
prev.next = cur.next
break
prev = prev.next
cur = cur.next
return new_head.next
def delete(node):
node.value = node.next.value
node.next = node.next.next
if __name__ == '__main__':
head = LinkedList(4)
head.next = LinkedList(5)
head.next.next = LinkedList(1)
node = head.next
head.next.next.next = LinkedList(9)
delete(node)
print_list(head)
import linked_list as ll import test_utils as tu from q06_odd_even import reorder_odd_even ll.print_list(reorder_odd_even(tu.gen_list_of_len(10)))
prev = curr
curr = next
return prev
def swap_n(l, n):
if l is None:
return None
prev = None
curr = l
i = 0
tail = curr
while curr and i < n:
next = curr.next
curr.next = prev
prev = curr
curr = next
i += 1
tail.next = swap_n(next, n)
return prev
if __name__ == '__main__':
l = LinkedList(1)
l.next = LinkedList(2)
l.next.next = LinkedList(3)
l.next.next.next = LinkedList(4)
l.next.next.next.next = LinkedList(5)
# print_list(swap_n(l, 2))
print_list(swap_n(l, 3))
def partition(l, x):
small = LinkedList(0)
small_header = small
large = LinkedList(0)
large_header = large
cur = l
while cur:
if cur.value < x:
small.next = cur
small = small.next
else:
large.next = cur
large = large.next
cur = cur.next
small.next = large_header.next
large.next = None
return small_header.next
if __name__ == '__main__':
l = LinkedList(1)
l.next = LinkedList(4)
l.next.next = LinkedList(3)
l.next.next.next = LinkedList(2)
l.next.next.next.next = LinkedList(5)
l.next.next.next.next.next = LinkedList(2)
x = 3
print_list(partition(l, x))
from linked_list import LinkedList, print_list
def plus_one(head):
carry = helper(head)
if carry == 1:
new_head = LinkedList(1)
new_head.next = head
return new_head
return head
def helper(head):
if not head:
return 1
carry = helper(head.next)
s = head.value + carry
head.value = s % 10
return s / 10
if __name__ == '__main__':
head = LinkedList(9)
head.next = LinkedList(9)
head.next.next = LinkedList(9)
res = plus_one(head)
print_list(res)
from linked_list import print_list, LinkedList
def remove_dup_from_sorted_list(head):
new_head = LinkedList(0)
prev = new_head
new_head.next = head
cur = head
while cur:
count = 0
while (cur.next and cur.value == cur.next.value):
count += 1
cur = cur.next
if count == 0:
prev.next = cur
prev = cur
cur = cur.next
prev.next = None
return new_head.next
if __name__ == '__main__':
head = LinkedList(1)
head.next = LinkedList(2)
head.next.next = LinkedList(3)
head.next.next.next = LinkedList(3)
head.next.next.next.next = LinkedList(4)
head.next.next.next.next.next = LinkedList(4)
head.next.next.next.next.next.next = LinkedList(5)
print_list(remove_dup_from_sorted_list(head))
#!/bin/python
from linked_list import create_list, print_list, print_separator, N, get_random_middle, get_last, visit_list
def get_instersection(root_1, root_2):
visit_list(root_1)
node = root_2
while node and not node.visited:
node.visited
node = node.next
return node
print "LOOP DETECTION"
root_1 = create_list(N)
root_2 = create_list(N)
random_node = get_random_middle(root_1, N)
last_node_2 = get_last(root_2)
last_node_2.next = random_node
print print_list(root_1)
print print_list(root_2)
intersect = get_instersection(root_1, root_2)
if intersect:
print intersect.value
else:
print "None"
print_separator()
p = p.next
p.next = l1 or l2
return dummy.next
def mergeTwoLists2(self, l1: ListNode, l2: ListNode) -> ListNode:
"""
Solution #2: recursively
Time: O(n)
Space: O(1)
"""
if not l1: return l2
if not l2: return l1
if l1.val < l2.val:
l1.next = self.mergeTwoLists2(l1.next, l2)
return l1
else:
l2.next = self.mergeTwoLists2(l1, l2.next)
return l2
solution = Solution()
l1 = create_list([1, 2, 3])
l2 = create_list([1, 2, 4])
ans1 = solution.mergeTwoLists1(l1, l2)
print_list(ans1) # [1,1,2,2,3,4]
l1 = create_list([1, 2, 3])
l2 = create_list([3, 4, 5, 6, 7])
ans2 = solution.mergeTwoLists2(l1, l2)
print_list(ans2) # [1, 2, 3, 3, 4, 5, 6, 7]
count = 1
while curr and count <= n:
next = curr.next
curr.next = prev
prev = curr
curr = next
count += 1
tail.next = curr
return prev
def reverse(l, m, n):
head = l
curr = l
count = 1
while curr:
if count == m - 1:
print curr.value
curr.next = helper(curr.next, n - count)
break
count += 1
curr = curr.next
return head
if __name__ == '__main__':
l = generate_list(range(1, 2))
m = 1
n = 1
print_list(reverse(l, m, n))
from linked_list import LinkedList, print_list
def reverse_list(head):
prev = None
while head:
temp = head.next
head.next = prev
prev = head
head = temp
return prev
if __name__ == '__main__':
head = LinkedList(1)
# head.next = LinkedList(2)
# head.next.next = LinkedList(3)
# head.next.next.next = LinkedList(4)
# head.next.next.next.next = LinkedList(5)
print_list(reverse_list(head))
