def heap_sort2(seq):
s = list(seq)
heap = Heap(s)
res = []
for _ in range(len(s)):
res.insert(0, heap.extract_max())
return res
def __init__(self, elems, cmp=cmp):
self.cmp = cmp
self.high = Heap([], cmp)
self.low = Heap([], lambda x, y: cmp(y, x))
for el in elems:
self.insert(el)
def prims(graph):
vertices = graph.keys()
Q = Heap(len(vertices))
parent = {}
src = vertices[0]
output = []
for vertex in vertices:
if vertex == src:
Q.insert((vertex, 0))
else:
Q.insert((vertex, float('inf')))
parent[vertex] = None
while not Q.isEmpty():
u, weight = Q.pop()
if parent[u] != None:
output.append([u, parent[u]])
edges = graph[u]
for edge in edges:
v, wt_v = edge
if v not in Q.minHeap_pos:
continue
ind_v = Q.minHeap_pos[v]
if wt_v < Q.minHeap[ind_v][1]:
parent[v] = u
Q.decreaseKey(ind_v, v, wt_v)
printPath(output)
def viterbi(param, observations, path_num=1):
assert (isinstance(param, HMMParameter))
probs, states = {}, {}
for state in param.statesof(observations[0]):
probs[state] = [
param.initial_prob(state) + param.emission(state, observations[0])
]
states[state] = {-len(observations): None}
for i in range(1, len(observations)):
for state in param.statesof(observations[i]):
max_tuple = max([(probs[s][-1] + param.transtion(s, state) +
param.emission(state, observations[i]), s)
for s in param.statesof(observations[i - 1])])
probs[state] = probs.get(state, []) + [max_tuple[0]]
states[state] = {
**states.get(state, {}), (i - len(observations)): max_tuple[1]
}
last_states = param.statesof(observations[-1])
heap = Heap(min(path_num, len(last_states)))
for state in last_states:
heap.push(probs[state][-1], state)
results = []
for item in sorted(heap):
index = -1
result = [item[1]]
while index > -len(observations) and states[
result[0]][index] is not None:
result.insert(0, states[result[0]][index])
index -= 1
results.insert(0, result)
return results
def test_key(self):
heap = Heap(lambda x: -x)
items = []
for i in self.items:
heap.push(i)
items.append(i)
self.assertEqual(heap.peek(), max(items))
class Queue:
def __init__(self):
self.size = 0
self.priority = 0
self.data = Heap()
def enqueue(self, elem):
elem_priority = (self.priority, elem)
self.data.add(elem_priority)
self.size += 1
def dequeue(self):
if self.is_empty():
raise Empty
elem_tuple = Heap.remove_min(self.data)
self.size -= 1
return elem_tuple[1]
def first(self):
if self.is_empty():
raise Empty
elem_tuple = Heap.min(self.data)
return elem_tuple[1]
def __len__(self):
return self.size
def is_empty(self):
return self.size == 0
def dijkstra(self, s=1):
heap = Heap()
starter = self.lookup[s]
starter.score = 0
cloud = set([starter])
def update(vertex):
for edge in vertex.edges:
target = edge.target
if target in cloud:
continue
def manipulator(v):
v.score = min(v.score, vertex.score + edge.weight)
if target in heap.tree:
heap.manipulate(target, manipulator)
else:
manipulator(target)
heap.push(target)
update(starter)
while not heap.is_empty():
vertex = heap.pop()
cloud.add(vertex)
update(vertex)
def shortest_path(adj, s):
arr, D, P = [], {}, {}
# initialize Distances and Parents
for v in adj:
P[v] = None
if v == s:
arr.append((0, v))
D[v] = 0
else:
arr.append((math.inf, v))
D[v] = math.inf
heap = Heap(arr)
while True:
v = heap.extract()
if v is None:
break
current = v[1]
for (w, e) in adj[current]:
nw = D[current] + w
if nw < D[e]:
D[e] = nw
P[e] = current
heap.decrease(D[e], e)
return (D, P)
def dijkstra(self, start, goal):
h = Heap(comp=operator.lt)
h.add(start, 0)
done = set()
costs = {start: 0}
preds = {}
explored = 0
while not h.is_empty():
explored += 1
curr = h.pop()['key']
cost = costs[curr]
done.add(curr)
if curr == goal:
return build_path(preds, curr), costs, explored, cost
for (neighbor, weight) in self.edges[curr]:
# 1. already done with this node: skip
if neighbor in done:
continue
# 2. have not yet seen this node: add
new_cost = cost + weight
if neighbor not in costs:
h.add(neighbor, new_cost)
costs[neighbor] = new_cost
preds[neighbor] = curr
continue
# 3. have already seen this node, and new cost is lower than old: update cost
if new_cost < costs[neighbor]:
h.set_priority(neighbor, new_cost)
costs[neighbor] = new_cost
preds[neighbor] = curr
return None, costs, explored, None
class MedianMaintainer:
"""The median is defined as ((n+1)/2)th element if n is odd and (n/2)th element if n is even."""
def __init__(self):
self.smaller = Heap(maxheap=True)
self.bigger = Heap()
self.median = float('inf')
def _balance(self):
if abs(len(self.smaller) - len(self.bigger)) > 1:
if len(self.smaller) > len(self.bigger):
self.bigger.insert_node(self.smaller.extract_root())
else:
self.smaller.insert_node(self.bigger.extract_root())
def append(self, num):
# choose where to place a new number.
if num > self.median:
self.bigger.insert_node(num)
else:
self.smaller.insert_node(num)
# Ensure heaps length do not differ by more than one.
self._balance()
# set median
self.median = self.smaller[0] if len(self.smaller) >= len(self.bigger) else self.bigger[0]
def optics(cluster):
j = 0
L = [[float('infinity'),float('infinity')]] * len(cluster.X)
X = range(len(cluster.X))
for p in X:
if not cluster.isProcessed(p):
N, pkerndist = cluster.kernlVectors(p, rtype = 'id')
cluster.markProcessed(p)
L[j] = [float('infinity'), pkerndist, p] # push p
j = j+1
seeds = Heap()
update(N, p, seeds, cluster)
q = seeds.pop()
while(q):
NN, qkerndist = cluster.kernlVectors(q, rtype = 'id')
L[j] = [cluster.vreachdist[q], qkerndist, q]
j = j+1
cluster.markProcessed(q)
update(NN, q, seeds, cluster)
q = seeds.pop()
return L
def __init__(self, words_stats): heap = Heap(True) for word in words_stats: node = TreeNode(word) node.setValue(words_stats[word]) heap.insert(node) self.root = HuffmanBinaryTree.buildTree(words_stats, heap)
def __init__(self, N):
"""
:type N: int
"""
self.N = N
self.heap = Heap(lambda i: -self.distance(i))
self.heap.push((-1, N))
def TestBuildMinHeap(self):
input = [random.randrange(100) for _ in range(100)]
h = Heap(input)
sorted_input = sorted(input)
for i in range(len(input)):
self.assertEqual(h.peek_min(), sorted_input[i])
self.assertEqual(h.extract_min(), sorted_input[i])
def dijkstraWithHeap(G, s, t):
bw = [0] * V
parent = [-1] * V
status = [2] * V
heap = Heap()
status[s] = 0
bw[s] = sys.maxsize
neighbors = G.neighbors(s)
for vertices in neighbors:
bw[vertices.dst] = vertices.bw
parent[vertices.dst] = s
status[vertices.dst] = 1
heap.insert(vertices.dst, bw[vertices.dst])
while status[t] != 0:
v = maxfringe(bw, status)
# print(v,end=" ")
status[v] = 0
neighbors = G.neighbors(v)
for i in range(len(neighbors)):
w = neighbors[i].dst
if status[w] == 2:
bw[w] = min(bw[v], neighbors[i].bw)
parent[w] = v
status[w] = 1
heap.insert(w, bw[w])
elif status[w] == 1 and bw[w] < min(bw[v], neighbors[i].bw):
heap.delete(w)
bw[w] = min(bw[v], neighbors[i].bw)
parent[w] = v
heap.insert(w, bw[w])
return bw[t]
def __dijkstra_util(self, actual_vertex: InfoElement, done: list,
priority_queue: heap.Heap):
for edge in actual_vertex.vertex.edge_list:
element = priority_queue.get_element(edge.target_vertex)[1]
if element != None and element.visited == False:
new_cost = actual_vertex.accumulated_cost + edge.weight
#Relaxation
if element.accumulated_cost > new_cost:
element.cost = edge.weight
element.accumulated_cost = new_cost
element.last_vertex = actual_vertex
priority_queue.heapify()
#No others elements to visit
if priority_queue.heap_size == 0:
return done
#Lightest vertex
top_element = priority_queue.extract()
top_element.visited = True
done.append(top_element)
return self.__dijkstra_util(top_element, done, priority_queue)
def __init__(self, size, size_factor=1.0):
self.size_factor = size_factor
self.root = None
binaryHeap = Heap(size)
for value in binaryHeap.getHeap():
self.add(value)
def astar(self, start, goal, heuristic):
h = Heap(comp=operator.lt)
start_cost = heuristic(start, goal)
h.add(start, start_cost)
actual_costs = {start: 0}
preds = {}
done = set()
explored = 0
while not h.is_empty():
explored += 1
curr = h.pop()['key']
cost = actual_costs[curr]
done.add(curr)
if curr == goal:
return build_path(preds, curr), actual_costs, h, explored, cost
for (neighbor, weight) in self.edges[curr]:
# 1. already done with this node: skip
if neighbor in done:
continue
# 2. have not yet seen this node: add
cost_so_far = cost + weight
total_cost = cost_so_far + heuristic(neighbor, goal)
if neighbor not in actual_costs:
h.add(neighbor, total_cost)
preds[neighbor] = curr
actual_costs[neighbor] = cost_so_far
continue
# 3. have already seen this node, and new cost is lower than old: update cost
if cost_so_far < actual_costs[neighbor]:
h.set_priority(neighbor, total_cost)
actual_costs[neighbor] = cost_so_far
preds[neighbor] = curr
return None, actual_costs, h, explored, None
def testData(data: list, fileObject):
'''
This function takes in a list of @data and a file object @fileObject
Creates a new Heap instance with the list of @data, and verifies min-heap
with checkHeap().
Inserts some new values into the heap with insertOne(), and repeatedly remove
the smallest item while maintaining heap using deleteOne().
'''
heap = Heap(data)
printHeap("Heap", heap, fileObject)
checkHeap(heap, fileObject)
insertOne(heap, 31, fileObject)
insertOne(heap, 14, fileObject)
# This portion repeatedly removes the smallest element at the root.
while heap.size() > 0:
# This portion changes the heap and should cause an error.
# Uncomment this portion to test checkHeap()
'''
if heap.size() == 10:
heap._heapList[7] = 4 # Error checker
'''
deleteOne(heap, fileObject) # this repeatedly remove smallest element.
class ProrityQueue:
def __init__(self):
self.heap = Heap()
self.help = 0
def enqueue(self, element, priority=0, maximum=True):
"""Insert element to queue.
If maximum = True builds queue based on maximum prioritet else maximu = False builds heap based on minimum prioritet"""
self.heap.insert((priority, self.help, element), maximum)
self.help += 1
return
def dequeue(self):
"""Delete element with queue"""
return self.heap.extract()[2]
def get_size(self):
"""Return size queue"""
return self.heap.get_size()
def __repr__(self):
"""Representation object."""
lista = [x[2] for x in self.heap.table[1:]]
return f'{lista}'
def dijkstra(graph, src, dest):
vertices = graph.keys()
Q = Heap(len(vertices))
parent = {}
for vertex in vertices:
if vertex == src:
Q.insert((vertex, 0))
else:
Q.insert((vertex, float('inf')))
while not Q.isEmpty():
u, wt_u = Q.pop()
if u == dest:
printPath(parent, src, dest)
break
else:
lst = graph[u]
for tup_v in lst:
v, wt_v = tup_v
if v not in Q.minHeap_pos:
continue
ind_v = Q.minHeap_pos[v]
current_wt = Q.minHeap[ind_v][1]
if wt_u + wt_v < current_wt:
new_wt = wt_u + wt_v
parent[v] = u
Q.decreaseKey(ind_v, v, new_wt)
class GetMapFromHeapWithSingleKeyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.h = Heap()
self.h.MakeHeap([11], 1)
def test(self):
self.assertEqual(11, self.h.GetMax())
self.assertIsNone(self.h.HeapArray[0])
def test_build_heaps(self):
array = []
for i in range(10000):
array.append(randint(-100, 100))
newHeap = Heap(array, 'max')
self.assertTrue(check_heap_prop(newHeap.array, newHeap.type))
newHeap = Heap(array, 'min')
self.assertTrue(check_heap_prop(newHeap.array, newHeap.type))
def TestKeyLambda(self):
input = [random.randrange(100) for _ in range(100)]
h = Heap(input, key=lambda x: x * -1)
sorted_input = sorted(input, reverse=True)
print(sorted_input)
for i in range(len(input)):
self.assertEqual(h.peek_min(), sorted_input[i])
self.assertEqual(h.extract_min(), sorted_input[i])
def TestMinHeapWithRandomInput(self):
input = [random.randrange(100) for _ in range(100)]
h = Heap()
for num in input:
h.insert(num)
sorted_input = sorted(input)
for i in range(len(input)):
self.assertEqual(h.extract_min(), sorted_input[i])
def get_top_predicted_list(user_id, business_to_check, number_of_prediction):
top_business = Heap(number_of_prediction)
for business_id in business_to_check:
predicted_rating = get_predicted_rating_for_business(
user_id, business_id)
if predicted_rating:
top_business.push(round(predicted_rating, 3), business_id)
return sorted(top_business.get_list(), reverse=True, key=lambda x: x[0])
def heap_sort(A, key=default_key):
""" Θ(nlgn) """
heap = Heap(A, key=key)
for i in reversed(range(1, heap._heap_size)):
heap._heap[0], heap._heap[i] = heap._heap[i], heap._heap[0]
heap._heap_size -= 1
heap._heapify(0)
return heap._heap
def test_max_heap_insert(self):
test_case = [i for i in range(1, 11)]
heap_type = 'max'
test_heap = Heap(heap_type)
for test_element in test_case:
test_heap.heap_insert(test_element)
self.assertEqual(test_element, test_heap.heap[0])
self.assertEqual(len(test_case), len(test_heap.heap))
def heapsort(items):
heap = Heap(items[:])
result = []
while heap.items:
result.append(heap.pop())
return result
def heap_sort2(seq):
heap = Heap(seq)
res = []
for i in range(len(seq)):
res.insert(0, heap.extract_max())
return res
