class Queue(object):
# initializes queue
def __init__(self):
self.__linked_list = SinglyLinkedList()
self.length = 0
# returns string representation of queue as "[item1, item2, ...]"
def __repr__(self):
return repr(self.__linked_list)
# returns boolean value of whether or not queue is empty
def is_empty(self):
return self.length == 0
# returns length of queue
def get_length(self):
return self.length
# pushes new item to back of queue
def push(self, item):
self.__linked_list.append(item)
self.length += 1
# returns item at front of queue and removes it
def pop(self):
item = self.__linked_list.head.data
self.__linked_list.remove_after(None)
self.length -= 1
return item
# returns item at the front of queue without removing
def peek(self):
return self.__linked_list.head.data
def main2():
sll = SinglyLinkedList()
for i in range(1,10):
sll.append(i)
print(sll)
print(len(sll))
sll[-9] = 100
print(sll[-9])
print(sll[1:3])
class Stack:
# linkedList-based stack
# class LinkedListStack:
def __init__(self):
self.storage = SinglyLinkedList()
def __len__(self):
return len(self.storage)
def push(self, value):
self.storage.append(value)
def pop(self):
return self.storage.remove_last() if len(self) > 0 else None
def top(self):
return self.storage.get_tail()
def test_exists(self):
""" Tests for membership.
"""
sll = SinglyLinkedList()
node1, node2, node3 = Node(1), Node(2), Node(3)
sll.append(node1)
sll.append(node2)
sll.append(node3)
self.assertTrue(sll.exists(node1))
self.assertTrue(sll.exists(node2))
self.assertTrue(sll.exists(node3))
self.assertFalse(sll.exists(Node(4)))
# Membership is based on object identity, not value
self.assertFalse(sll.exists(Node(1)))
class Stack:
def __init__(self):
self.size = 0
self.storage = SinglyLinkedList()
def __len__(self):
return self.size
def push(self, value):
self.storage.append(value)
self.size += 1
def pop(self):
self.size = len(self.storage)
if self.size > 0:
item = self.storage.remove_last()
self.size -= 1
return item
else:
None
def test_delete(self):
""" Test a delete method.
"""
sll = SinglyLinkedList()
node1, node2, node3 = Node(1), Node(2), Node(3)
sll.append(node1)
sll.append(node2)
sll.append(node3)
self.assertEquals(str(sll), '1, 2, 3')
sll.delete(node2)
self.assertEquals(str(sll), '1, 3')
# It silently handles missing items
sll.delete(Node(4))
self.assertEquals(str(sll), '1, 3')
class Queue:
"""
Queue will be implemented with a linked list as the start
of the queue as the tail, and the end of the queue as the head.
This way, enqueue's and dequeue's are O(1).
Enqueue is appending from the tail, dequeueing is reassigning
the pointer of the head to None.
"""
def __init__(self, iterable=None):
self.queue = SinglyLinkedList()
if iterable:
for item in iterable:
self.queue.append(item)
def is_empty(self):
return self.queue.is_empty()
def length(self):
return self.queue.size
def front(self):
if self.queue.is_empty():
return None
return self.queue.head.data
def enqueue(self, data):
self.queue.append(data)
def dequeue(self):
if self.queue.size < 1:
raise ValueError("queue is empty")
output = self.front()
self.queue.delete(output)
return output
def test_append(self):
""" Test an append method.
"""
sll = SinglyLinkedList()
sll.append(Node('first'))
sll.append(Node('second'))
sll.append(Node('third'))
self.assertEquals(str(sll), 'first, second, third')
def test_append_start_empty(self):
linkedlist = SinglyLinkedList()
linkedlist.append(1)
assert linkedlist[0] == 1
linkedlist.append(2)
assert linkedlist[1] == 2
linkedlist.append(10)
assert linkedlist[2] == 10
assert linkedlist.num_nodes == 3
assert len(linkedlist) == 3
def test_find(self):
ls = SinglyLinkedList()
ls.append("a").append("b").append("c")
self.assertIsInstance(ls.find("c"), Node)
self.assertIsNone(ls.find("d"))
class TestSinglyLinkedList(unittest.TestCase):
def setUp(self):
self.my_list = SinglyLinkedList()
def test_basic_initialization_and_repr(self):
self.assertEqual(repr(self.my_list), '[]')
def test_append(self):
self.my_list.append(4)
self.my_list.append(3)
self.my_list.append(7)
self.my_list.append(-17)
self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')
def test_prepend(self):
self.my_list.prepend(4)
self.my_list.prepend(3)
self.my_list.prepend(7)
self.my_list.prepend(-17)
self.assertEqual(repr(self.my_list), '[-17, 7, 3, 4]')
def test_insert_after(self):
self.my_list.insert_after(None, 4)
self.my_list.insert_after(None, 3)
self.my_list.insert_after(self.my_list.tail, 7)
self.my_list.insert_after(self.my_list.head, -17)
self.assertEqual(repr(self.my_list), '[3, -17, 4, 7]')
def test_insert_sorted(self):
self.my_list.insert_after(None, 4)
self.my_list.insert_after(None, 3)
self.my_list.insert_after(None, 7)
self.assertEqual(repr(self.my_list), '[7, 3, 4]')
self.my_list.insert_sorted(2)
self.my_list.insert_sorted(8)
self.assertEqual(repr(self.my_list), '[2, 7, 3, 4, 8]')
self.my_list.remove_after(None)
self.my_list.remove_after(None)
self.my_list.remove_after(None)
self.my_list.remove_after(None)
self.my_list.remove_after(None)
self.my_list.insert_sorted(8)
self.my_list.insert_sorted(7)
self.my_list.insert_sorted(6)
self.my_list.insert_sorted(5)
self.assertEqual(repr(self.my_list), '[5, 6, 7, 8]')
self.my_list.reverse()
self.assertEqual(repr(self.my_list), '[8, 7, 6, 5]')
def test_remove_after(self):
self.my_list.append(4)
self.my_list.append(3)
self.my_list.append(7)
self.my_list.append(-17)
self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')
self.my_list.remove_after(None)
self.assertEqual(repr(self.my_list), '[3, 7, -17]')
self.my_list.remove_after(self.my_list.head)
self.assertEqual(repr(self.my_list), '[3, -17]')
self.my_list.remove_after(self.my_list.tail)
self.assertEqual(repr(self.my_list), '[3, -17]')
self.my_list.remove_after(None)
self.my_list.remove_after(None)
self.my_list.remove_after(None)
self.assertEqual(repr(self.my_list), '[]')
def test_array(self):
self.my_list.append(4)
self.my_list.append(3)
self.my_list.append(7)
self.my_list.append(-17)
self.assertEqual(self.my_list.array(), [4, 3, 7, -17])
def test_search(self):
self.my_list.append(4)
self.my_list.append(3)
self.my_list.append(-17)
self.my_list.append(7)
self.assertEqual(self.my_list.search(4).data, 4)
self.assertEqual(self.my_list.search(3).data, 3)
self.assertEqual(self.my_list.search(-17).data, -17)
self.assertEqual(self.my_list.search(17), None)
def test_reverse(self):
self.my_list.append(4)
self.my_list.append(3)
self.my_list.append(7)
self.my_list.append(-17)
self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')
self.my_list.reverse()
self.assertEqual(repr(self.my_list), '[-17, 7, 3, 4]')
self.my_list.reverse()
self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')
def test_remove_duplicates(self):
self.my_list.append(4)
self.my_list.append(3)
self.my_list.append(3)
self.my_list.append(3)
self.my_list.append(7)
self.my_list.append(-17)
self.assertEqual(repr(self.my_list), '[4, 3, 3, 3, 7, -17]')
self.my_list.remove_duplicates()
self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')
current.next = previous
previous = current
current = next
return previous
def reverse_linked_list_recursive(head):
if head.next is None:
return head
temp = reverse_linked_list_recursive(head.next)
head.next.next = head
head.next = None
return temp
if __name__ == '__main__':
lst = SinglyLinkedList()
lst.append('0')
lst.append('1')
lst.append('2')
lst.append('3')
lst.head = reverse_linked_list(lst.head)
lst.head = reverse_linked_list_recursive(lst.head)
print(lst)
test_stack.add_tail(2)
test_stack.add_tail(3)
print(test_stack)
test_stack.remove_tail()
print(test_stack)
test_stack.remove_tail()
test_stack.remove_tail()
print(test_stack)
print()
print(
'Stack implementation using collections.deque (TC append() - O(1), TC pop() - O(1))'
)
test_stack = deque()
print(test_stack)
test_stack.append(1)
test_stack.append(2)
test_stack.append(3)
print(test_stack)
test_stack.pop()
print(test_stack)
test_stack.pop()
test_stack.pop()
print(test_stack)
print()
print(
'Stack implementation using queue.LifoQueue (TC put() - O(1), TC get() - O(1))'
)
test_stack = LifoQueue()
print(test_stack.qsize())
from singly_linked_list import SinglyLinkedList
my_list = SinglyLinkedList()
my_list.print()
for i in range(10):
my_list.append(i + 1)
my_list.print()
for i in range(10):
my_list.prepend(i + 1)
my_list.print()
value = my_list.access(3)
print('my_list.access(3) = ' + str(value))
my_list.insert(8, 128)
my_list.print()
my_list.remove(4)
my_list.print()
my_list.set_head(10)
my_list.print()
def test_insert(self):
ls = SinglyLinkedList()
ls.append("a").append("b").append("d")
ls.insert(2, "c")
self.assertEqual("c", ls.head.next.next.value)
def test_prepend(self):
ls = SinglyLinkedList()
ls.append("b").append("c")
ls.prepend("a")
self.assertEqual("a", ls.head.value)
def test_singly_linked_list_append(N):
print("Testing SinglyLinkedList")
l = SinglyLinkedList()
print(f"Appending {int(N)} values")
[l.append(i) for i in range(int(N))]
def test_append_start_filled(self):
linkedlist = SinglyLinkedList([1, 2, 3, 4, 5])
linkedlist.append(6)
assert linkedlist[5] == 6
linkedlist.append("hello")
assert linkedlist[6] == "hello"
test_queue.add_tail(2)
test_queue.add_tail(3)
print(test_queue)
test_queue.remove_head()
print(test_queue)
test_queue.remove_head()
test_queue.remove_head()
print(test_queue)
print()
print(
'Queue implementation using collections.deque (TC append() - O(1), TC popleft() - O(1))'
)
test_queue = deque()
print(test_queue)
test_queue.append(1)
test_queue.append(2)
test_queue.append(3)
print(test_queue)
test_queue.popleft()
print(test_queue)
test_queue.popleft()
test_queue.popleft()
print(test_queue)
print()
print(
'Queue implementation using queue.Queue (TC put() - O(1), TC get() - O(1))'
)
test_queue = Queue()
print(test_queue.qsize())
def test_append(self):
ls = SinglyLinkedList()
ls.append("a").append("b")
self.assertEqual(2, ls.length)
self.assertEqual("a", ls.head.value)
self.assertEqual("b", ls.head.next.value)
