def test_append_multiple_with_initial_value(self):
linked = SinglyLinkedList(1000)
linked.append(100)
linked.append(200)
linked.append(300)
self.assertEqual(linked.as_list(), [1000, 100, 200, 300])
def test_remove(self):
linked = SinglyLinkedList(100)
linked.append(200)
linked.append(300)
linked.remove(1)
self.assertEqual(linked.as_list(), [100, 300])
def test_as_list(self):
linked = SinglyLinkedList()
linked.append(100)
linked.append(200)
linked.append(300)
self.assertEqual(linked.as_list(), [100, 200, 300])
class deleteFromMiddleTests(unittest.TestCase):
def setUp(self):
self.linked_list = SinglyLinkedList(SinglyLinkedNode(0))
for i in range(3):
self.linked_list.append(SinglyLinkedNode(i+1))
def test_1(self):
node = self.linked_list.head.child
deleteFromMiddle(node)
traversal = self.linked_list.traverse()
self.assertEqual(len(traversal), 3)
self.assertEqual(traversal, [0, 2, 3])
def test_2(self):
node = self.linked_list.head.child.child
deleteFromMiddle(node)
traversal = self.linked_list.traverse()
self.assertEqual(len(traversal), 3)
self.assertEqual(traversal, [0, 1, 3])
def test_3(self):
for _ in range(2):
node = self.linked_list.head.child
deleteFromMiddle(node)
traversal = self.linked_list.traverse()
self.assertEqual(len(traversal), 2)
self.assertEqual(traversal, [0, 3])
def test_4(self):
node = self.linked_list.head.child.child.child
self.assertRaises(ValueError, deleteFromMiddle, node)
class deleteFromMiddleTests(unittest.TestCase):
def setUp(self):
self.linked_list = SinglyLinkedList(SinglyLinkedNode(0))
for i in range(3):
self.linked_list.append(SinglyLinkedNode(i + 1))
def test_1(self):
node = self.linked_list.head.child
deleteFromMiddle(node)
traversal = self.linked_list.traverse()
self.assertEqual(len(traversal), 3)
self.assertEqual(traversal, [0, 2, 3])
def test_2(self):
node = self.linked_list.head.child.child
deleteFromMiddle(node)
traversal = self.linked_list.traverse()
self.assertEqual(len(traversal), 3)
self.assertEqual(traversal, [0, 1, 3])
def test_3(self):
for _ in range(2):
node = self.linked_list.head.child
deleteFromMiddle(node)
traversal = self.linked_list.traverse()
self.assertEqual(len(traversal), 2)
self.assertEqual(traversal, [0, 3])
def test_4(self):
node = self.linked_list.head.child.child.child
self.assertRaises(ValueError, deleteFromMiddle, node)
def test_insert_in_the_middle(self):
linked = SinglyLinkedList(100)
linked.append(200)
linked.append(300)
linked.insert(1000, 1)
self.assertEqual(linked.as_list(), [100, 1000, 200, 300])
def test_item_setting_by_index_overrides_previous_value_at_the_end(self):
linked = SinglyLinkedList()
linked.append(100)
linked.append(200)
linked.append(300)
linked[2] = 400
self.assertEqual(linked.as_list(), [100, 200, 400])
def test_direct_access_to_elements_more_than_one_element(self):
linked = SinglyLinkedList()
linked.append(100)
linked.append(200)
linked.append(300)
linked.append(400)
self.assertEqual(linked[2], 300)
def test_remove_at_the_beginning_with_multiple_values(self):
linked = SinglyLinkedList(100)
linked.append(200)
linked.append(300)
linked.append(400)
linked.remove(0)
self.assertEqual(linked.as_list(), [200, 300, 400])
def test_remove_at_the_end(self):
linked = SinglyLinkedList(100)
linked.append(200)
linked.append(300)
linked.append(400)
linked.append(500)
linked.remove(4)
self.assertEqual(linked.as_list(), [100, 200, 300, 400])
class SetupSinglyLinkedList:
def setup_method(self):
self.test_list = SinglyLinkedList()
self.test_list.append(42)
self.test_list.append(33)
self.test_list.append('spam')
self.test_list.prepend([])
self.test_list.prepend({'a': 42})
def test_2(self):
linked_list = SinglyLinkedList()
values = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
for value in values:
linked_list.append(SinglyLinkedNode(value))
partition(linked_list, 10)
traversal = linked_list.traverse()
self.assertEqual(traversal, [9, 8, 7, 6, 5, 4, 3, 2, 1, 10])
def test_2(self):
linked_list = SinglyLinkedList()
values = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
for value in values:
linked_list.append(SinglyLinkedNode(value))
partition(linked_list, 10)
traversal = linked_list.traverse()
self.assertEqual(traversal, [9, 8, 7, 6, 5, 4, 3, 2, 1, 10])
def test_problem(self):
linked_list = SinglyLinkedList(SinglyLinkedNode(-1))
for i in range(100):
linked_list.append(SinglyLinkedNode(i))
linked_list.append(SinglyLinkedNode(i))
for i in range(100):
linked_list.append(SinglyLinkedNode(0))
deduplicate(linked_list)
self.assertEqual(linked_list.traverse(), [-1] + range(100))
def test_1(self):
linked_list = SinglyLinkedList()
values = [3, 5, 8, 5, 10, 2, 1]
for value in values:
linked_list.append(SinglyLinkedNode(value))
partition(linked_list, 5)
traversal = linked_list.traverse()
self.assertEqual(set(traversal[:3]), set([1, 2, 3]))
self.assertEqual(set(traversal[3:]), set([5, 8, 10]))
self.assertEqual(len(traversal), 7)
def test_1(self):
linked_list = SinglyLinkedList()
values = [3, 5, 8, 5, 10, 2, 1]
for value in values:
linked_list.append(SinglyLinkedNode(value))
partition(linked_list, 5)
traversal = linked_list.traverse()
self.assertEqual(set(traversal[:3]), set([1,2,3]))
self.assertEqual(set(traversal[3:]), set([5, 8, 10]))
self.assertEqual(len(traversal), 7)
def test_3(self):
linked_list = SinglyLinkedList(SinglyLinkedNode(0))
last = 100000
current = last
current_node = SinglyLinkedNode(current)
while current > 0:
current -= 1
current_node = SinglyLinkedNode(current, current_node)
linked_list.append(current_node)
k = 7623
self.assertEqual(toLast(k, linked_list), last - k)
def create_list(self, length_neck, length_loop):
neck = SinglyLinkedList()
for i in range(length_neck):
neck.prepend(SinglyLinkedNode(length_neck - i))
loop = SinglyLinkedList()
for i in range(length_loop):
loop.prepend(SinglyLinkedNode(length_neck + length_loop - i))
if loop.head is not None:
end = loop.head
while end.child is not None:
end = end.child
end.child = loop.head
neck.append(loop.head)
return neck
def create_list(self, length_neck, length_loop):
neck = SinglyLinkedList()
for i in range(length_neck):
neck.prepend(SinglyLinkedNode(length_neck - i))
loop = SinglyLinkedList()
for i in range(length_loop):
loop.prepend(SinglyLinkedNode(length_neck + length_loop - i))
if loop.head is not None:
end = loop.head
while end.child is not None:
end = end.child
end.child = loop.head
neck.append(loop.head)
return neck
def test_inequality_with_values(self):
first = SinglyLinkedList()
first.append(100)
first.append(200)
first.append(300)
second = SinglyLinkedList()
second.append(110)
second.append(200)
second.append(300)
self.assertNotEqual(first, second)
def sumLists(a, b):
current_a = a.head
current_b = b.head
result = SinglyLinkedList()
# Digit addition step
while (current_a is not None) and (current_b is not None):
result.append(SinglyLinkedNode(current_a.value + current_b.value))
current_a = current_a.child
current_b = current_b.child
while current_a is not None:
result.append(SinglyLinkedNode(current_a.value))
current_a = current_a.child
while current_b is not None:
result.append(SinglyLinkedNode(current_b.value))
current_b = current_b.child
# Carries step
current_result = result.head
while current_result is not None:
if current_result.value >= 10:
carry = int(current_result.value/10)
current_result.value = current_result.value - 10*carry
if current_result.child is not None:
current_result.child.value += carry
else:
current_result.child = SinglyLinkedNode(carry)
current_result = current_result.child
return result
def sumLists(a, b):
current_a = a.head
current_b = b.head
result = SinglyLinkedList()
# Digit addition step
while (current_a is not None) and (current_b is not None):
result.append(SinglyLinkedNode(current_a.value + current_b.value))
current_a = current_a.child
current_b = current_b.child
while current_a is not None:
result.append(SinglyLinkedNode(current_a.value))
current_a = current_a.child
while current_b is not None:
result.append(SinglyLinkedNode(current_b.value))
current_b = current_b.child
# Carries step
current_result = result.head
while current_result is not None:
if current_result.value >= 10:
carry = int(current_result.value / 10)
current_result.value = current_result.value - 10 * carry
if current_result.child is not None:
current_result.child.value += carry
else:
current_result.child = SinglyLinkedNode(carry)
current_result = current_result.child
return result
class SinglyLinkedListQueue:
def __init__(self, max_length):
self._queue = SinglyLinkedList()
self._length = 0
self._max_length = max_length
def enqueue(self, value):
if self._length == self._max_length:
raise ValueError("Overflow")
self._length += 1
self._queue.append(value)
def dequeue(self):
if self._length == 0:
raise ValueError("Underflow")
self._length -= 1
return self._queue.remove(0).value
def increase_max_length(self):
self._max_length += 1
def as_list(self):
return self._queue.as_list()
def time_append():
n = 5000
print('time_append, n =', n)
with timewith(' linked list '):
container = SLL()
for x in range(n):
container.append(x)
del container
with timewith(' list '):
container = list()
for x in range(n):
container.append(x)
del container
with timewith(' deque '):
container = deque()
for x in range(n):
container.append(x)
del container
def test_2(self):
linked_list = SinglyLinkedList(SinglyLinkedNode(-1))
for i in range(100):
linked_list.append(SinglyLinkedNode(i))
self.assertIsNone(toLast(1000, linked_list))
def test_1(self):
linked_list = SinglyLinkedList(SinglyLinkedNode(0))
for i in range(1, 100):
linked_list.append(SinglyLinkedNode(i))
self.assertEqual(toLast(1, linked_list), 98)
def test_append_single(self):
linked = SinglyLinkedList()
linked.append(100)
self.assertEqual(linked.as_list(), [100])
def test_direct_access_to_elements(self):
linked = SinglyLinkedList()
linked.append(100)
self.assertEqual(linked[0], 100)
def test_item_setting_by_index_with_a_previous_value(self):
linked = SinglyLinkedList()
linked.append(100)
linked[1] = 200
self.assertEqual(linked.as_list(), [100, 200])
