def linked_list_add(first_linked_list, second_linked_list, carry): """ The numbers are stored in reverse order """ if not first_linked_list and not second_linked_list and carry == 0: return None value = carry if first_linked_list: value = value + first_linked_list.data if second_linked_list: value = value + second_linked_list.data result = value % 10 # the last digit result_linked_list = LinkedListNode(result) if first_linked_list or second_linked_list: next_node = linked_list_add(None if not first_linked_list else first_linked_list.next, None if not second_linked_list else second_linked_list.next, 0 if value < 10 else 1) result_linked_list.next = next_node return result_linked_list
def linked_list_add_forward(linked_list_one, linked_list_two, carry): # convert the first list to an integer current_node = linked_list_one first_integer_value = 0 while current_node: first_integer_value = first_integer_value * 10 + current_node.data current_node = current_node.next current_node = linked_list_two second_integer_value = 0 while current_node: second_integer_value = second_integer_value * 10 + current_node.data current_node = current_node.next result = first_integer_value + second_integer_value # convert result back to a linked list divided_by_ten = result next_node = None while divided_by_ten != 0: current_digit = divided_by_ten % 10 divided_by_ten = divided_by_ten / 10 new_node = LinkedListNode(current_digit) new_node.next = next_node next_node = new_node return new_node
def create_circular_list(length_before_loop, loop_length): root = LinkedListNode(random.randint(0, 9)) previous_node = root # create the section before the loop for i in range(0, length_before_loop): new_node = LinkedListNode(random.randint(0, 10)) previous_node.next = new_node previous_node = new_node # this is the node the loop points to loop_back_node = previous_node print("The beginning of the loop is: " + str(loop_back_node)) # create the nodes in the loop for i in range(0, loop_length): new_node = LinkedListNode(random.randint(0, 10)) previous_node.next = new_node previous_node = new_node # create the cycle - point the end of the linked list back to the # "loop back node" previous_node.next = loop_back_node return root
def push(self, value): """Method for adding a node to the list""" node = LinkedListNode(value) if self.is_empty(): self.head = node else: node.next = self.head self.head = node
def test_get_tail(self): test_list = LinkedList() test_node_1 = LinkedListNode(1) test_node_2 = LinkedListNode(2) test_node_3 = LinkedListNode(3) test_list.append(test_node_1) test_list.append(test_node_2) test_list.append(test_node_3) self.assertEqual(test_list.get_tail().value, 3)
def create_random_linked_list(number_of_nodes): root = LinkedListNode(random.randint(0, 9)) current_node = root for i in range(0, number_of_nodes - 1): random_key = random.randint(0, 9) new_node = LinkedListNode(random_key) current_node.next = new_node current_node = new_node return root
def test_multiple_append(self): test_list = LinkedList() test_node_1 = LinkedListNode(1) test_node_2 = LinkedListNode(2) test_node_3 = LinkedListNode(3) test_list.append(test_node_1) test_list.append(test_node_2) test_list.append(test_node_3) self.assertEqual(test_list.head.value, 1) self.assertEqual(test_list.head.next.value, 2) self.assertEqual(test_list.head.next.next.value, 3)
def linked_list_sort(l: LinkedList) -> LinkedList: if not l.head: return l pivot_node = l.head pivot = pivot_node.value less_head = less_tail = LinkedListNode(0) greater_head = greater_tail = LinkedListNode(0) curr = l.head.next while curr: if curr.value < pivot: less_tail.next = curr less_tail = less_tail.next else: greater_tail.next = curr greater_tail = greater_tail.next curr = curr.next less_list = LinkedList() less_list.head = less_head.next less_tail.next = None less_list = linked_list_sort(less_list) greater_list = LinkedList() greater_list.head = greater_head.next greater_tail.next = None greater_list = linked_list_sort(greater_list) dummy_head = tail = LinkedListNode(0) if less_list: tail.next = less_list.head tail = less_list.tail tail.next = pivot_node tail = tail.next if greater_list: tail.next = greater_list.head tail = greater_list.tail l.head = dummy_head.next l.tail = tail tail.next = None # print(l) return l
def enqueue(self, value): """Method for adding a node to the end of the queue""" node = LinkedListNode(value) if self.is_empty(): self.head = node self.tail = node else: self.tail.next = node self.tail = node
def reversed(ll): new_head = None curr = ll.head while curr: new_head = LinkedListNode(curr.val, new_head) curr = curr.next reversed_ll = LinkedList() reversed_ll.head = new_head return reversed_ll
def test_append(self): """Can append number""" test_list = LinkedList() test_list.append(4) self.assertEqual(test_list.head.value, 4) """Can append node""" test_list = LinkedList() test_node = LinkedListNode(4) test_list.append(test_node) self.assertEqual(test_list.head.value, 4)
def build_palindrome_list(): root = LinkedListNode(5) previous_node = root for i in range(0, 2): new_node = LinkedListNode(random.randint(0, 9)) previous_node.next = new_node previous_node = new_node stack = [] current_node = root while current_node.next != None: # all but the last one stack.append(current_node.data) current_node = current_node.next while len(stack) != 0: data = stack.pop() new_node = LinkedListNode(data) previous_node.next = new_node previous_node = new_node return root
def create_list(tree): queue = [tree.root] level = 0 list_of_lists = [] while queue: head = LinkedListNode(queue[0].value) current_node = head children = [] if queue[0].left: children.append(queue[0].left) if queue[0].right: children.append(queue[0].right) for node in queue[1:]: current_node.next = LinkedListNode(node.value) current_node = current_node.next if node.left: children.append(node.left) if node.right: children.append(node.right) list_of_lists.append(head) queue = children return list_of_lists
def test_delete_next(self): test_node_1 = LinkedListNode(1) test_node_1.append(2) test_node_1.append(3) self.assertEqual(test_node_1.next.value, 2) test_node_1.delete_next() self.assertEqual(test_node_1.next.value, 3)
def sum_lists_forward(list1, list2): """ Returns sum of list1 and list2 as if the ones digit were in the first node. [7, 1, 6] + [5, 9, 2] -> [2, 1, 9] """ overflow = 0 node1 = list1.head node2 = list2.head new_list = LinkedList() new_tail = None while node1 or node2 or overflow: node1_val = node1.val if node1 else 0 node2_val = node2.val if node2 else 0 overflow, digit_sum = divmod(node1_val + node2_val + overflow, 10) if new_list.head: new_tail.next = LinkedListNode(digit_sum) new_tail = new_tail.next else: new_list.head = LinkedListNode(digit_sum) new_tail = new_list.head node1 = node1.next if node1 else None node2 = node2.next if node2 else None return new_list
def get_sorted_line_seg_endpoints(trajectory_line_segments): line_segment_endpoints = [] cur_id = 0 for traj_segment in trajectory_line_segments: list_node = LinkedListNode(traj_segment) line_segment_endpoints.append(TrajectoryLineSegmentEndpoint(traj_segment.line_segment.start.x, \ traj_segment, cur_id, list_node)) line_segment_endpoints.append(TrajectoryLineSegmentEndpoint(traj_segment.line_segment.end.x, \ traj_segment, cur_id, list_node)) cur_id += 1 return sorted(line_segment_endpoints, key=attrgetter('horizontal_position'))
def get_sorted_line_seg_endpoints(tls_list): line_segment_endpoints = [] cur_id = 0 for tls in tls_list: list_node = LinkedListNode(tls) e1 = TrajectoryLineSegmentEndpoint(tls.rsegment.start.x, tls, cur_id, list_node) e2 = TrajectoryLineSegmentEndpoint(tls.rsegment.end.x, tls, cur_id, list_node) line_segment_endpoints.append(e1) line_segment_endpoints.append(e2) cur_id += 1 return sorted(line_segment_endpoints, key=attrgetter('horizontal_position'))
def multiple_linked_list(x, y, result=None, carry_over=0): if not x and not y: return result x_vlaue = x.value if x else 0 y_value = y.value if y else 0 tens, ones = divmod(x_vlaue + y_value + carry_over, 10) if not result: result = LinkedList(ones) else: result.append_node_to_tail(LinkedListNode(ones)) return multiple_linked_list(x.next if x else None, y.next if y else None, result=result, carry_over=tens)
def test_str(): """ Linked list can be made into string form. """ ll = LinkedListNode(2) ll.appendToTail(1) ll.appendToTail(2) ll.appendToTail(6) ll.appendToTail(6) expected = '[2] -> [1] -> [2] -> [6] -> [6]' actual = str(ll) assert actual == expected
def test_exceptions(self): list, node = self.get_single_node_list() list.remove_node(node) self.assertRaises(Exception, list.remove_node, node) self.assertRaises(Exception, list.remove_node, LinkedListNode(0))
def get_single_node_list(self): list = LinkedList() node = LinkedListNode(0) list.add_last_node(node) return (list, node)
def reverse(node): if node == None: return None if node.next == None: return node prev_node = None current = node while current: temp = current.next current.next = prev_node prev_node = current current = temp return (prev_node) def display_all_values(node): while True: print(node.value) if node.next == None: break node = node.next a = LinkedListNode(1) a.next = LinkedListNode(2) a.next.next = LinkedListNode(3) a.next.next.next = LinkedListNode(4) display_all_values(a) display_all_values(reverse(a))
given only access to that node """ from linked_list import LinkedListNode import random def delete_middle(middle_node): """ Since you are not given access to the head of the list, you can simply copy the data from the next node to the current node and then delete the next node. This solution does not work if the node to be deleted is the last node. """ middle_node.data = middle_node.next.data middle_node.next = middle_node.next.next root = LinkedListNode(5) current_node = root for i in range(0, 10): random_key = random.randint(0, 10) new_node = LinkedListNode(random_key) current_node.next = new_node current_node = new_node if i == 4: middle_node = current_node print("Original list: " + str(root)) delete_middle(middle_node) print("List with middle node deleted: " + str(root))
def test_init(self): test_node = LinkedListNode(4) self.assertEqual(test_node.value, 4)
def test_it(self): node1 = LinkedListNode(1) node2 = LinkedListNode(2) node3 = LinkedListNode(3) node4 = LinkedListNode(4) node5 = LinkedListNode(5) # List1, node1 -> 2 -> 3 node1.next = node2 node2.next = node3 # List2, node5 -> 4 -> 3 node5.next = node4 node4.next = node3 assert extract_common_node(node1, node5) == [node3]
""" Write a program that reverses a linked list without using more than O(1) storage """ from linked_list import LinkedListNode import random head = LinkedListNode(random.randint(0, 20)) previous = head for i in range(0, 5): node = LinkedListNode(random.randint(0, 20)) previous.next = node previous = node node.next = None print(head) current = head next = current.next current.next = None while next: old_next = next.next next.next = current current = next next = old_next print(current)
""" Write a function to delete a node (except the tail) in a singly linked list, given only access to that node. Suppose 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. https://leetcode.com/problems/delete-node-in-a-linked-list/ """ from linked_list import LinkedListNode # @param head LinkedListNode the head of a linked list # @param node LinkedListNode the linked list node to be deleted def delete_node(node): if node and node.next: node.data = node.next.data node.next = node.next.next if __name__ == '__main__': head = LinkedListNode(1) head.next = LinkedListNode(2) head.next.next = LinkedListNode(3) head.next.next.next = LinkedListNode(4) delete_node(head.next.next) assert str(head) == "1, 2, 4" print("All test cases passed.")
def test_it3(self): node1 = LinkedListNode(1) node2 = LinkedListNode(2) node3 = LinkedListNode(3) node4 = LinkedListNode(4) node5 = LinkedListNode(1) node1.next = node2 node2.next = node3 node3.next = node4 node4.next = node5 assert not is_circulation(node1)
""" Given a sorted linked list, delete all duplicates such that each element appears only once. For example, Given 1->1->2, return 1->2. Given 1->1->2->3->, return 1->2->3. """ from linked_list import LinkedListNode head = LinkedListNode(1) head.next = LinkedListNode(1) head.next.next = LinkedListNode(2) # @param {LinkedListNode} head head of a linked list def remove_duplicates(head): if not head or not head.next: return head slow_pointer = head fast_pointer = head.next while fast_pointer: if slow_pointer.data == fast_pointer.data: slow_pointer.next = fast_pointer.next fast_pointer = fast_pointer.next else: slow_pointer = slow_pointer.next fast_pointer = fast_pointer.next return head
def test_memorize_nodes(self): node1 = LinkedListNode(1) node2 = LinkedListNode(2) node3 = LinkedListNode(3) node4 = LinkedListNode(2) node5 = LinkedListNode(1) node1.next = node2 node2.next = node3 node3.next = node4 node4.next = node5 actual = memorize_nodes(node1) expect = {1: [node1, node5], 2: [node2, node4], 3: [node3]} assert actual == expect