def is_palindrome_reverse(head): """Iteratively check if is palindrome by comparing to reversed.""" prev = None current = head counter = 0 while current: counter += 1 node = Node(current.value) node.next = prev prev = node current = current.next for _ in range(counter // 2): if head.value != prev.value: return False head = head.next prev = prev.next return True
def setUp(self): self.list_test = LinkedList() self.list_test.add_in_tail(Node(12)) self.list_test.add_in_tail(Node(73)) self.list_test.add_in_tail(Node(73)) self.list_test.add_in_tail(Node(12)) self.list_test.add_in_tail(Node(73)) self.list_test.add_in_tail(Node(73))
def test_find_all(self): lst = self.list_test.find_all(12) list_value = [node.value for node in lst] self.assertEqual(list_value, [12, 12]) list_test = LinkedList() self.assertEqual(list_test.find_all(12), []) list_test = LinkedList() list_test.add_in_tail(Node(12)) lst = list_test.find_all(12) list_value = [node.value for node in lst] self.assertEqual(list_value, [12])
def test_delete(self): """ Tests that the Node reference pointer has been deleted. """ node = Node(1) node.insert_after(2) self.assertEqual(node.next.value, 2) node.delete() self.assertEqual(node.next, None)
def test_insert_after(self): """ Tests that a new Node with the inputted value has been inserted after this one. """ node = Node("testing1") node.insert_after("testing2") self.assertEqual(node.next.value, "testing2") node.insert_after("testing3") self.assertEqual(node.next.value, "testing3") self.assertEqual(node.next.next.value, "testing2")
def partition(list, key): current_node = list.head pre = SingleList() post = SingleList() while current_node is not None: if current_node.data != key: if current_node.data > key: post.append(current_node.data) else: pre.append(current_node.data) current_node = current_node.next current_node = pre.head new_node = Node(key, post.head) while current_node.next is not None: current_node = current_node.next current_node.next = new_node return pre
def nth_to_last_node(n, head): slow = head fast = head for _ in range(n): if not slow.nextnode: raise LookupError('Error: n is larger than the linked List') fast = fast.nextnode while fast.nextnode: slow = slow.nextnode fast = fast.nextnode return slow a = Node(1) b = Node(2) c = Node(3) d = Node(4) e = Node(5) a.nextnode = b b.nextnode = c c.nextnode = d d.nextnode = e target_node = nth_to_last_node(3, a) print(target_node.value)
def _pre_fill(node, n): """Prefill n zero nodes in front of the first node.""" for _ in range(n): node = Node(0, node) return node
def test_new_node_instance_has_data_equal_to_None(): """Test that a newly created instance of the Node class has data equal to None.""" new_node = Node() assert new_node.data is None
def test_sum_list(self): list_test_1 = LinkedList() list_test_1.add_in_tail(Node(12)) list_test_1.add_in_tail(Node(38)) list_test_1.add_in_tail(Node(12)) list_test_1.add_in_tail(Node(55)) list_test_2 = LinkedList() list_test_2.add_in_tail(Node(120)) list_test_2.add_in_tail(Node(550)) list_test_2.add_in_tail(Node(1280)) list_test_2.add_in_tail(Node(550)) self.assertEqual(sum_list(list_test_1, list_test_2), [132, 588, 1292, 605]) list_test_2 = LinkedList() list_test_2.add_in_tail(Node(120)) list_test_2.add_in_tail(Node(550)) list_test_2.add_in_tail(Node(1280)) self.assertEqual(sum_list(list_test_1, list_test_2), None)
def push(self, x): newnode = Node(x) self.s.insert(newnode)
def _test_one_node(self, name=name): node = Node('x') self.assertTrue(func(node))
def test_node(self): node = Node(0) self.assertEqual(node.data, 0) self.assertEqual(node.next, None)
def test_instantiation(self): """ Tests that a new Node has been instantiated """ node = Node(1) self.assertIsInstance(node, Node)
def push(self, value): new_node = Node(value) self.storage.add_to_tail(new_node) self.size += 1
def create_linked_list_from_array(linked_list, input_list): for elem in input_list: linked_list.add_node_to_list(Node(elem))
def test_remove_dups(self): # Check removing dups from the empty list. lst = SinglyLinkedList() remove_dups(lst) self.assertEqual(lst.size, 0) # Check removing dups from the list wiht one element in it. lst = SinglyLinkedList() lst.insert_tail(Node(1)) remove_dups(lst) self.assertEqual(lst.size, 1) self.assertEqual(lst.head.data, 1) # Check removing dups from the tree with repeated element in it. lst = SinglyLinkedList() original_data = [1, 1] for i in range(len(original_data)): lst.insert_tail(Node(original_data[i])) remove_dups(lst) self.assertEqual(lst.size, 1) self.assertEqual(lst.head.data, 1) lst = SinglyLinkedList() original_data = [1, 1, 1, 1, 1] for i in range(len(original_data)): lst.insert_tail(Node(original_data[i])) remove_dups(lst) self.assertEqual(lst.size, 1) self.assertEqual(lst.head.data, 1) # Check removing dups from the tree with mixed data. lst = SinglyLinkedList() original_data = [1, 5, 3, 5, 4, 8, 1, 12, 33, 5] expected_data = [1, 5, 3, 4, 8, 12, 33] for i in range(len(original_data)): lst.insert_tail(Node(original_data[i])) remove_dups(lst) self.assertEqual(lst.size, len(expected_data)) node = lst.head for i in range(len(expected_data)): self.assertEqual(node.data, expected_data[i]) node = node.next lst = SinglyLinkedList() original_data = [38, 49, 51, 1080, 12, -48, -48, 1080] expected_data = [38, 49, 51, 1080, 12, -48] for i in range(len(original_data)): lst.insert_tail(Node(original_data[i])) remove_dups(lst) self.assertEqual(lst.size, len(expected_data)) node = lst.head for i in range(len(expected_data)): self.assertEqual(node.data, expected_data[i]) node = node.next # Check removing dups from the tree with no repeated data. lst = SinglyLinkedList() original_data = [1, 2, 3, 4, 5] expected_data = [1, 2, 3, 4, 5] for i in range(len(original_data)): lst.insert_tail(Node(original_data[i])) remove_dups(lst) self.assertEqual(lst.size, len(expected_data)) node = lst.head for i in range(len(expected_data)): self.assertEqual(node.data, expected_data[i]) node = node.next
def __init__(self, data, next_node=None, previous_node=None): Node.__init__(self) self.previous_node = previous_node
if l1 == p2: return p2 else: if p2._next == None: break else: p2 = p2._next if l1._next == None: break else: l1 = l1._next return 'No intersecting node' if __name__ == '__main__': l1 = Node(np.random.randint(1, 10)) l2 = Node(np.random.randint(1, 10)) for i in range(np.random.randint(0, 3)): l1.append(np.random.randint(1, 10)) for i in range(np.random.randint(0, 3)): l2.append(np.random.randint(1, 10)) inter = Node(item=128) l1.append(inter) l2.append(inter) for i in range(3): l1.append(np.random.randint(1, 10)) for i in range(np.random.randint(0, 5)): l2.append(np.random.randint(1, 10)) print('L1:') display(l1)
marker1 = node marker2 = node while marker1 != None and marker2.nextnode != None: marker1 = marker1.nextnode marker2 = marker2.nextnode.nextnode #check if the markers have crossed if marker1 == marker2: return True # Case where the marker ahead reaches the end of the list return False a = Node(1) b = Node(2) c = Node(3) a.nextnode = b b.nextnode = c c.nextnode = a # Cycle List x = Node('ro') y = Node('mo') z = Node('to') x.nextnode = y y.nextnode = z
def test_node_initialization(self): """"test initialization of Node""" n = Node(10) self.assertEqual(n.val, 10)
def reverse(head): current = head prevNode = None nextNode = None while current: nextNode = current.nextnode current.nextnode = prevNode prevNode = current current = nextNode return a = Node(1) b = Node(2) c = Node(3) d = Node(4) a.nextnode = b b.nextnode = c c.nextnode = d print(a.nextnode.value) print(b.nextnode.value) print(c.nextnode.value) # Reversing the Linked List print("##################") reverse(a)
def test_print(self): """ Test the list printing. """ sll = SinglyLinkedList(Node('first')) sll.insert_after(sll.first_node, Node('second')) self.assertEquals(str(sll), 'first, second')
def forward_sum(x, y): x, y = _pad_zeros(x, y) first, carry = _forward_sum(x, y) return Node(carry, first) if carry else first
if l._next == None: for i in node_list: if l == i: return l return False else: node_list.append(l) p = l._next l._next = None l = p return 'Error' if __name__ == '__main__': l = Node(np.random.randint(1, 10)) count = 1 p = l node = l for i in range(2): l.append(np.random.randint(1, 10)) p = p._next count += 1 print('p should be', p) for i in range(2): l.append(np.random.randint(1, 10)) count += 1 if np.random.randint(0, 2) > 0: l.append(p) count += 1 print('Should be True')
def enqueue(self, value): new_node = Node(value) self.storage.add_to_tail(new_node) self.size += 1