def __init__(self, func=None):
self.heapList = List([
0
]) # 0 here just for simple integer division in following methods
# func takes 1 argument (each element in list) and return a value that will be used for comparison.
# If None, element itself will be used to compare with its child value
self.func = func if func else lambda x: x
def heapify(self, iterable):
"""Build the heap from a iterable"""
self.heapList = List([0])
self.heapList.extend(iterable)
i = len(self.heapList) // 2
while i > 0:
self._percDown(i)
i -= 1
return self
def inorder(btree: BinaryTree) -> List:
"""
Return a List of values in inorder
"""
newList = List()
if btree is not None:
newList.extend(inorder(btree.left))
newList.append(btree.key)
newList.extend(inorder(btree.right))
return newList
def put(self, key, value):
hash_value = self._hash(key)
self._k += 1
if self.slots[hash_value] is None:
# the slot is empty, key does not exists
self.slots[hash_value] = List([key])
self.payloads[hash_value] = List([value])
else:
# Hash Collision, search the key in the list
try:
i = self.slots[hash_value].index(key)
except ValueError:
# key is not in List, append new key and value
self.slots[hash_value].append(key)
self.payloads[hash_value].append(value)
else:
# key is already in list, change value
self.payloads[hash_value][i] = value
self._k -= 1
def heap_sort(alist: list, key=None) -> list:
"""A heap sort algorithm can be implemented by push and pop items in a heap data structure."""
newList = List()
hp = BinaryHeap(func=key)
for item in alist:
hp.heappush(item)
for _ in range(len(alist)):
newList.append(hp.heappop())
return newList
def preorder(btree: BinaryTree) -> List:
"""
Return a List of values in predorder
"""
newList = List()
newList.append(btree.key)
if btree.left:
newList.extend(preorder(btree.left))
if btree.right:
newList.extend(preorder(btree.right))
return newList
def layer_traversal(btree: BinaryTree) -> List:
"""Return a list of items in btree from layer to layer."""
res = List()
q = Queue()
q.enqueue(btree)
while not q.isEmpty():
currNode = q.dequeue()
res.append(currNode.key)
if currNode.left:
q.enqueue(currNode.left)
if currNode.right:
q.enqueue(currNode.right)
return res
def __init__(self):
self.flag = False # to indicate whether the traversal is a complete word
self.child = List([None] * 26) # 26 letters from a-z
def __str__(self):
s = List()
for key, value in self.items():
s.append(f'{str(key)}: {str(value)}')
return f'Hashtable([ {", ".join(s)} ])'
def __init__(self, size=11):
self._size = size # default size
self.slots = List([None] * size)
self.payloads = List([None] * size)
self._k = 0