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
