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