def Prim(V, s): """Prim algorithm. Returns list T containing edges of minimum spanning tree and T_sum, the sum of its weights.""" # initialize structures Q = set() D = MinHeap() P = {} # set initial values for v in V: Q.add(v) D[v] = float('inf') D[s] = 0 P[s] = None while len(Q) != 0: v, _ = D.extract_min() Q.remove(v) for w, d in v.get_neighbors(): if w in Q: if d < D[w]: D[w] = d P[w] = v tree = [] tree_sum = 0 for v in P: if P[v] is not None: tree.append((P[v], v)) tree_sum += D[v] return tree, tree_sum
def __init__(self, maze_file): self.close = dict() self.open = MinHeap() self.open_dict = dict() self.grid = [] self.start_state = None self.goal_state = None for i in range(max_size): self.grid.append([]) with open(maze_file, 'r') as f: line_row = 0 for line in f: self.grid.append([]) line = line.rstrip() if not line: continue if not self.start_state: self.start_state = line_to_coord(line) self.start_state.g = 0 continue if not self.goal_state: self.goal_state = line_to_coord(line) continue for pos in line: self.grid[line_row].append(True if pos == '1' else False) line_row += 1
def dijkstra(graph, root): vertices = graph.keys() n = len(vertices) # Initialize the priority queue inf = float("inf") pq = MinHeap([(v, inf) for v in graph.keys()]) pq.change_priority(root, 0) # Other initializations parent = collections.defaultdict(lambda: None) selected = set() cost = collections.defaultdict(lambda: inf) cost[root] = 0 while len(selected) < n: u = pq.min() du = cost[u] = pq.get_priority(u) selected.add(u) pq.take_min() for (v, w) in graph[u].items(): if v not in selected and pq.get_priority(v) > du + w: pq.change_priority(v, du + w) parent[v] = u return cost, parent
def get_trie(s): # get frequencies: frequencies = {} for c in s: if c not in frequencies: frequencies[c] = 1 else: frequencies[c] += 1 # build trie: heap = MinHeap() for c in frequencies: heap.insert(Node(frequencies[c], c)) while heap.size() > 1: left = heap.extractmin() right = heap.extractmin() assert (left is not None) assert (right is not None) assert (left.frequency >= 0) assert (right.frequency >= 0) frequency = left.frequency + right.frequency node = Node(frequency) node.left = left node.right = right heap.insert(node) return heap.extractmin()
def dijkstra( self, valor_vertice_origem ) -> (Dict[Vertice, DistanciaVerticeOrigem], Dict[Vertice, Vertice]): distancia = {} pai = {} vertice_origem = self.obtem_vertice(valor_vertice_origem) if not vertice_origem: return None fila_min_heap = MinHeap() #inicialização for vertice in self.vertices.values(): distancia[vertice] = DistanciaVerticeOrigem(vertice, float("inf")) pai[vertice] = None fila_min_heap.insere(distancia[vertice]) #print(f"HEAP: {fila_min_heap}") #print(f"Vertice Origem: {vertice_origem.valor}") #escreva o código abaixo para preencher as veriaveis distancia e pai adequadamente distancia[vertice_origem].distancia = 0 while fila_min_heap.pos_ultimo_item > 0: vertice = self.obtem_vertice( fila_min_heap.retira_min().vertice.valor) for adjacencia in vertice.adjacencias: self.dijkstra_relax(fila_min_heap, vertice, adjacencia, distancia, pai) return distancia, pai
class Calendar(object): def __init__(self): self.events = MinHeap() self.mapper = {} def add(self, record): self.events.add(record.timestamp) if record.timestamp in self.mapper: self.mapper[record.timestamp].append(record) else: self.mapper[record.timestamp] = [record] def getlatest(self): rec_time = self.events.extractMin() rec_list = self.mapper[rec_time] # Logic here decides how to handle simultaneous events. # Current Implementation - extract departure events first record = None index = -1 for idx in range(len(rec_list)): if rec_list[idx].event_type == "E": index = idx break if index < 0: record = rec_list.pop(0) else: record = rec_list.pop(index) if not len(rec_list): del self.mapper[rec_time] return record
def merge_sorted_lists(): k = 10 n = 10 min_value = 0 max_value = 30 sorted_lists = generate_sorted_lists(k,n,min_value,max_value) sorted_list = SingleLinkedList() heap = MinHeap([], 0) # fill in the 1st batch for i, l in sorted_lists.items(): heap.add(IdAndValue(i, l.pop(0))) while len(sorted_lists) > 0: item = heap.pop() sorted_list.append(item.get_value()) list_id = item.get_id() if list_id in sorted_lists: value = sorted_lists[list_id].pop(0) if len(sorted_lists[list_id]) <= 0: sorted_lists.pop(list_id) heap.add(IdAndValue(list_id, value)) else: list_id, list = sorted_lists.items()[0] heap.add(IdAndValue(list_id, list.pop(0))) if len(list) <= 0: sorted_lists.pop(list_id) while not heap.is_empty(): sorted_list.append(heap.pop()) print k*n, len(sorted_list), sorted_list
def Dijkstra(V, s): """Dijkstra algorithm. Returns MinHeap D containing minimum distances and dict P containing previous node.""" # initialize structures Q = set() D = MinHeap() P = {} # set initial values for v in V: Q.add(v) D[v] = float('inf') D[s] = 0 P[s] = None while len(Q) != 0: v, _ = D.extract_min() Q.remove(v) for w, d in v.get_neighbors(): new_d = D[v] + d if w in Q: if new_d < D[w]: D[w] = new_d P[w] = v return D, P
def heap_sort(items): heap = MinHeap(items) sorted_list = [] for i in xrange(len(items)): sorted_list.append(heap.remove_min()) return sorted_list
def k_smallest(arr, k): h = MinHeap() for item in arr: h.insert(item) for i in range(k): smallest = h.extract() print(smallest) return
def test1(): minhp = MinHeap() for idx in range(10): minhp.add(idx + 1) minhp.add(20 - idx) minhp.printer() for idx in range(20): print minhp.extractMin()
def single_item_test(): h = MinHeap() h.insert(1) assert h.heap_data[0] == 1 assert_size(h, 1) elem = h.extract() assert elem == 1 assert_size(h, 0)
def test_exch(count): """Test exchange method.""" heap = MinHeap() _ = [heap.insert(randint(0, 100)) for i in range(MAX_ITER)] pos_a = randint(0, len(heap.heap) - 1) val_a = heap.heap[pos_a] pos_b = randint(0, len(heap.heap) - 1) val_b = heap.heap[pos_b] heap.exch(val_a, val_b) assert heap.heap[pos_a] == val_b and heap.heap[pos_b] == val_a
def sort_k_sorted(array, k): sorted = [] min_heap = MinHeap(array[:k + 2]) for i in range(len(array)): sorted.append(min_heap.extract_min()) if i + k + 2 < len(array): min_heap.insert(array[i + k + 2]) return sorted
def heapSort(arr): """ Sorts an array by creating a heap and continually extracting minimums. Array is not sorted in place. :type arr: List[] :rtype: List[] """ heap = MinHeap() heap.createMinHeap(arr) return heap.extractAll()
def test_insere(self): arr_test = [1, -8, -11, -14] arr_heap_esperado = [ [None, -12, -9, -6, -4, -3, -5, -2, -1, 1], [None, -12, -9, -6, -8, -3, -5, -2, -1, -4], [None, -12, -11, -6, -9, -3, -5, -2, -1, -4], [None, -14, -12, -6, -9, -3, -5, -2, -1, -4], ] #testa inserção no heap vazio for val_inserir in arr_test: objHeap = MinHeap() objHeap.insere(val_inserir) self.assertListEqual( [None, val_inserir], objHeap.arr_heap, f"Inserção incorreta ao inserir o valor {val_inserir} no heap {[None,12,9,6,4,3,5,2,1]}, esperado: {[None,val_inserir]} obtido: {objHeap.arr_heap}" ) for i, val_inserir in enumerate(arr_test): objHeap = MinHeap() objHeap.arr_heap = [None, -12, -9, -6, -4, -3, -5, -2, -1] objHeap.insere(val_inserir) self.assertListEqual( arr_heap_esperado[i], objHeap.arr_heap, f"Inserção incorreta ao inserir o valor {val_inserir} no heap {[None,12,9,6,4,3,5,2,1]}, esperado: {arr_heap_esperado[i]} obtido: {objHeap.arr_heap}" )
def dijkstra_relax(self, fila_min_heap: MinHeap, vertice_u: Vertice, vertice_v: Vertice, distancia: Dict[Vertice, DistanciaVerticeOrigem], pai: Dict[Vertice, Vertice]): distancia_aresta = vertice_u.adjacencias[vertice_v] if distancia[vertice_v].distancia > (distancia[vertice_u].distancia + distancia_aresta): distancia[vertice_v].distancia = distancia[ vertice_u].distancia + distancia_aresta pai[vertice_v] = vertice_u fila_min_heap.insere(distancia[vertice_v])
def dijkstra_relax(self, fila_min_heap: MinHeap, vertice_u: Vertice, vertice_v: Vertice, distancia: Dict[Vertice, DistanciaVerticeOrigem], pai: Dict[Vertice, Vertice]): dist = distancia[vertice_u].distancia vert = vertice_u.adjacencias dist = dist + vert[vertice_v] if distancia[vertice_v].distancia > dist: distancia[vertice_v].distancia = dist pai[vertice_v] = vertice_u fila_min_heap.insere(distancia[vertice_v])
def heapFullTest(): """ Various tests for Heap class, using both MinHeaps and MaxHeaps, including sorting and random operations. """ print("Testing MinHeap: sorting") for i in range(1, 21): if heapRandomSort(250, True): print "Test", i, "successful" else: print "Test", i, "failed" print("\nTesting MaxHeap: sorting") for i in range(1, 21): if heapRandomSort(250, False): print "Test", i, "successful" else: print "Test", i, "failed" print("\nTesting MinHeap: general") for i in range(1, 21): if heapRandomTest(250, True): print "Test", i, "successful" else: print "Test", i, "failed" print("\nTesting MaxHeap: general") for i in range(1, 21): if heapRandomTest(250, False): print "Test", i, "successful" else: print "Test", i, "failed" print("\nTesting MinHeap: other operations") ar = [1, 4, 501, -200, 32, 7, 65, -1, 20000, -34, 17] min_heap = MinHeap() min_heap.createMinHeap(ar) print min_heap.extractMin() print min_heap.extractMin() print min_heap.extractMin() max_heap = MaxHeap() max_heap.createMaxHeap(ar) print max_heap.extractMax() print max_heap.extractMax() print max_heap.extractMax() print "Max: ar", max( ar), "min_heap", min_heap.maximum(), "max_heap", max_heap.maximum() print "Min: ar", min( ar), "min_heap", min_heap.minimum(), "max_heap", max_heap.minimum()
def test_empty(self): mh = MinHeap() self.assertTrue(mh.empty()) mh.append(1) self.assertFalse(mh.empty()) mh.pop() self.assertTrue(mh.empty())
def incomplete_tree_test(): h = MinHeap() h.insert(2) h.insert(1) assert h.heap_data[0] == 1 assert h.heap_data[1] == 2 assert_size(h, 2) elems = [] elems.append(h.extract()) elems.append(h.extract()) assert elems == [1, 2] assert_size(h, 0)
def heap_sort(arr): sorted_arr = [] min_heap = MinHeap(array=arr) for i in range(len(arr)): sorted_arr.append(min_heap.extract_min()) for i in range(len(sorted_arr)): arr.append(sorted_arr[i])
def sort(array): heap = MinHeap() for i in array: heap.push(i) out = [] while True: try: out.append(heap.pop()) except: break return out
class PriorityQueue: def __init__(self): self.heap = MinHeap() def enqueue(self, priority, item): self.heap.push(PriorityQueueItem(priority, item)) def dequeue(self): try: return self.heap.pop().value except: return None
def BFS(self, v): """ Runs breadth-first search from the source vertex v. Returns a matrix with distances from v, or None if v does not exist. """ if v >= self.vertexCount(): return None # can't be run; vertex doesn't exist # initialize the vertex queue, the "visited" set s, and the distances from v q = MinHeap() s = set() distance = [float("inf")] * self.vertexCount() # insert the source vertex into q and set its distance as 0 q.insert(KeyValuePair(0, v)) s.add(v) distance[v] = 0 # loop through all vertices, in order of distance from v, relaxing edges out of current vertex kvp = q.extractMin() while kvp: v = kvp.value d = kvp.key # relax all edges out of current vertex v edges = self._adj[v] for e in edges: if e.dest not in s: s.add(e.dest) distance[e.dest] = d + 1 q.insert(KeyValuePair(distance[e.dest], e.dest)) # get next-lowest distance vertex kvp = q.extractMin() return distance
def prim(graph, root): vertices = graph.keys() n = len(vertices) # Initialize the priority queue inf = float("inf") pq = MinHeap([(v, inf) for v in graph.keys()]) pq.change_priority(root, 0) # Other initializations parent = collections.defaultdict(lambda: None) selected = set() cost = 0 mst = [] while len(selected) < n: u = pq.take_min() selected.add(u) for (v, w) in graph[u].items(): if not v in selected and w < pq.get_priority(v): pq.change_priority(v, w) parent[v] = u pu = parent[u] if pu != None: mst.append((min(u, pu), max(u, pu))) cost += graph[u][pu] return cost, mst
def test_len(self): mh = MinHeap() self.assertTrue(len(mh) == 0) mh.append(1) self.assertTrue(len(mh) == 1) mh.append(1) self.assertTrue(len(mh) == 2) mh.pop() self.assertTrue(len(mh) == 1) mh.pop() self.assertTrue(len(mh) == 0)
def sort_k_sorted(arr, k): ans = [] h = MinHeap() for i in range(k + 1): h.insert(arr[i]) for i in range(k + 1, len(arr)): smallest = h.extract() ans.append(smallest) h.insert(arr[i]) while not h.is_empty(): smallest = h.extract() ans.append(smallest) return ans
def dijkstra_relax(self, fila_min_heap: MinHeap, vertice_u: Vertice, vertice_v: Vertice, distancia: Dict[Vertice, DistanciaVerticeOrigem], pai: Dict[Vertice, Vertice]): ''' print(f"U: {vertice_u.obtem_valor()} | V: {vertice_v.obtem_valor()}") print(distancia) print(pai) print(fila_min_heap) ''' #"vertice_u.adjacencias[vertice_v]" -> peso da aresta (y,v). if distancia[vertice_v].distancia > (distancia[vertice_u].distancia + vertice_u.adjacencias[vertice_v]): distancia[vertice_v].distancia = (distancia[vertice_u].distancia + vertice_u.adjacencias[vertice_v]) pai[vertice_v] = vertice_u fila_min_heap.insere(distancia[vertice_v])
def kLargestElement(arr, k): minH = MinHeap(arr[:k]) minH.convertToHeap() for x in arr[k:]: min_ele = minH.getMin() if min_ele < x: minH.replaceMin(x) return minH.getMin()
class Median: def __init__(self): self.h_low = MaxHeap() self.h_high = MinHeap() def add_element(self, value): if self.h_low.heap_size == 0 or value < self.h_low.max(): self.h_low.insert(value) if self.h_low.heap_size - self.h_high.heap_size > 1: self.h_high.insert(self.h_low.extract_max()) else: self.h_high.insert(value) if self.h_high.heap_size - self.h_low.heap_size > 1: self.h_low.insert(self.h_high.extract_min()) def get_median(self): if (self.h_low.heap_size + self.h_high.heap_size) % 2 == 0: return self.h_low.max(), self.h_high.min() else: if self.h_low.heap_size > self.h_high.heap_size: return self.h_low.max() else: return self.h_high.min() def get_maxheap_elements(self): return self.h_low.heap def get_minheap_elements(self): return self.h_high.heap
def cria_arv_geradora_minima( self, valor_vertice_inicial) -> Dict[Vertice, Vertice]: pai = {} set_ja_explorado = set() peso = {} vertice_inicial = self.obtem_vertice(valor_vertice_inicial) if not vertice_inicial: return None fila_min_heap = MinHeap() for vertice in self.vertices.values(): pai[vertice] = None peso[vertice] = PesoVertice(vertice, float("inf")) peso[vertice_inicial].peso = 0 fila_min_heap.insere(peso[vertice_inicial]) #print(f"HEAP: {fila_min_heap}") #print(f"Vertice Origem: {vertice_inicial.valor}") #print(f"HEAP vertice origem: {fila_min_heap.retira_min().vertice_destino.valor}") while len(fila_min_heap.arr_heap) > 1: vertice = self.obtem_vertice( fila_min_heap.retira_min().vertice_destino.valor) set_ja_explorado.add(vertice) for adjacencia in vertice.adjacencias: distancia_aresta = vertice.adjacencias[adjacencia] if adjacencia not in set_ja_explorado and distancia_aresta < peso[ adjacencia].peso: pai[adjacencia] = vertice peso[adjacencia].peso = distancia_aresta fila_min_heap.insere(peso[adjacencia]) return pai
def prim(graph, root): vertices = graph.keys() n = len(vertices) # Initialize the priority queue inf = float("inf") pq = MinHeap([(v, inf) for v in graph.keys()]) pq.change_priority(root, 0) # Other initializations parent = collections.defaultdict(lambda: None) selected = set() cost = 0 mst = [] while len(selected) < n: u = pq.take_min() selected.add(u) for (v, w) in graph[u].items(): if not v in selected and w < pq.get_priority(v): pq.change_priority(v, w) parent[v] = u pu = parent[u] if pu != None: mst.append( (min(u,pu), max(u,pu)) ) cost += graph[u][pu] return cost, mst
def get_static_top_k(nums, k): """ get top-K of static data :param nums: :param k: :return: """ if len(nums) <= k: return nums min_h = MinHeap(nums[:k], k) # one time use min_h.build_heap() # compare data with heap top for n in range(k, len(nums)): tmp = min_h.get_top() if nums[n] > tmp: # if larger, change data min_h.remove_top() min_h.insert(nums[n]) return min_h.get_data()
class MedianMaintenance: def __init__(self): self.hlow_heap = MaxHeap() self.hhigh_heap = MinHeap() def compute_median(self, i): self.insert_heap(i) self.balance_heap() return self.median() def balance_heap(self): if self.hhigh_heap.size - self.hlow_heap.size > 1 : # rebalance heap to keep it balanced high = self.hhigh_heap.extract_min() self.hlow_heap.insert(high) elif self.hlow_heap.size - self.hhigh_heap.size > 1: low = self.hlow_heap.extract_max() self.hhigh_heap.insert(low) def insert_heap(self, i): if self.hlow_heap.is_empty(): low = None else: low = self.hlow_heap.peek_max() if self.hhigh_heap.is_empty(): high = None else: high = self.hhigh_heap.peek_min() if low is None or i < low: self.hlow_heap.insert(i) elif high is not None and i > high: self.hhigh_heap.insert(i) else:# i wedged inbetween insert in first heap by default self.hlow_heap.insert(i) def median(self): if self.hhigh_heap.size - self.hlow_heap.size == 1: return self.hhigh_heap.peek_min() else:# default choice when hlow is bigger/same size as hhigh return self.hlow_heap.peek_max()
def test_min_heap_sorting(self): # seed for consistant testing and reproductibility for seed in xrange(10): random.seed(seed) heap = MinHeap() shuffled_nums = [int(random.random() * 20 - 10) for _ in xrange(1000)] nums = sorted(shuffled_nums) for n in shuffled_nums: heap.insert(n) for n in nums: self.assertEqual(n, heap.pop()) heap.heapify(shuffled_nums) for n in nums: self.assertEqual(n, heap.pop())
class SinglePercentileTracker(object): ''' A class that tracks a single percentile''' def __init__(self, percentile): self.percentile_tracked = percentile self.lheap = MaxHeap() self.rheap = MinHeap() self.size = 0 self.percentile = None def add(self, num): # An addition to a list is O(log n) since look up is O(1) # insertions are O(log n), and worst case pop is O(log n) # and everything is done a constant number of times. In these # cases, n is the size of the larger of the two heaps self.size += 1 n = (self.percentile_tracked / 100.0) * (self.size + 1) # The left heap should always be the floor of n, so we have the # floor(n)th ranked node as the max node in the left heap, and the # min node of the right heap will be the nth+1 ranked node. lsize = int(math.floor(n)) # Push the num on to the proper heap if num > self.percentile: self.rheap.push(num) else: self.lheap.push(num) # if the left heap isn't the right size, push or pop the nodes # to make sure it is. if self.lheap.size() < lsize: self.lheap.push(self.rheap.pop()) elif self.lheap.size() > lsize: self.rheap.push(self.lheap.pop()) # Take the integer part of n and grab the nth and nth+1 # ranked nodes. Then take the nth node as the base # and add the fractional part of n * nth+1 ranked node to get a # weighted value between the two. This is your percentile. ir = int(n) fr = n - ir low_data = self.lheap.get(0) high_data = self.rheap.get(0) self.percentile = fr * (high_data - low_data) + low_data def add_list(self, lst): # Add list is O(k * log n) where k is len(lst) and n is # the size of the larger of the two heaps for l in lst: self.add(l)
def shortest_paths(self, v): ''' Computes the shortest path distances from a source vertex to all other vertices using Dijkstra's algorithm. ''' processed = {} # mapping of processed vertices to geodesic distance candidates = {} # mapping of candidate vertices to their Dijkstra scores; exists for convenience of O(1) lookups trace = [] # stores edges in order of processing; used to extract shortest paths def dijkstra_score(src, dest): return processed[src] + self.getWeight(src, dest) # Initialize Dijkstra scores for n in self.nodes: if n == v: processed[n] = 0 for dest in self.edges[n]: score = dijkstra_score(n, dest) if dest not in candidates or score < candidates[dest]: candidates[dest] = score else: if n not in candidates: candidates[n] = float('inf') # heapify node/score tuples, provide comparison key unprocessed = MinHeap(list(candidates.items()), lambda x:x[1]) # compute shortest paths while not unprocessed.is_empty(): n,s = unprocessed.extract_min() processed[n] = s candidates.pop(n) if len(trace) == 0: trace.append(Edge(v, n)) # Investigate KeyError when using WeightedEdge else: src = trace[-1].getDestination() trace.append(Edge(src, n)) # Investigate KeyError when using WeightedEdge for dest in self.edges[n]: if dest in candidates: unprocessed.delete((dest, candidates[dest])) score = dijkstra_score(n, dest) best = min(candidates[dest], score) candidates[dest] = best unprocessed.insert((dest, best)) return (processed, PathFinder(trace))
def median_maintenance(data): yield data[0] if data[0] < data[1]: h_high, h_low = MinHeap([data[1]]), MaxHeap([data[0]]) else: h_high, h_low = MinHeap([data[0]]), MaxHeap([data[1]]) median = h_low.extract_max() h_low.insert(median) yield median for k in data[2:]: lower, upper = h_low.extract_max(), h_high.extract_min() if k <= lower: h_low.insert(k) else: h_high.insert(k) h_low.insert(lower) h_high.insert(upper) if abs(h_high.size() - h_low.size()) > 1: if h_high.size() > h_low.size(): h_low.insert(h_high.extract_min()) else: h_high.insert(h_low.extract_max()) if (h_high.size() + h_low.size()) % 2 == 0 or h_low.size() > h_high.size(): median = h_low.extract_max() h_low.insert(median) yield median else: median = h_high.extract_min() h_high.insert(median) yield median
def __init__(self): self.hlow_heap = MaxHeap() self.hhigh_heap = MinHeap()
def least_cost_path(graph,start,dest,cost): """Find and return the least cost path in graph from start vertex to dest vertex. Efficiency: If E is the number of edges, the run-time is O( E log(E) ). Args: graph (Graph): The digraph defining the edges between the vertices. start: The vertex where the path starts. It is assumed that start is a vertex of graph. dest: The vertex where the path ends. It is assumed that start is a vertex of graph. cost: A function, taking the two vertices of an edge as parameters and returning the cost of the edge. For its interface, see the definition of cost_distance. Returns: list: A potentially empty list (if no path can be found) of the vertices in the graph. If there was a path, the first vertex is always start, the last is always dest in the list. Any two consecutive vertices correspond to some edge in graph. >>> graph = Graph({1,2,3,4,5,6}, [(1,2), (1,3), (1,6), (2,1), (2,3), (2,4), (3,1), (3,2), (3,4), (3,6), (4,2), (4,3), (4,5), (5,4), (5,6), (6,1), (6,3), (6,5)]) >>> weights = {(1,2): 7, (1,3):9, (1,6):14, (2,1):7, (2,3):10, (2,4):15, (3,1):9, (3,2):10, (3,4):11, (3,6):2, (4,2):15, (4,3):11, (4,5):6, (5,4):6, (5,6):9, (6,1):14, (6,3):2, (6,5):9} >>> cost = lambda u, v: weights.get((u, v), float("inf")) >>> least_cost_path(graph, 1,5, cost) [1, 3, 6, 5] """ reached = {} runners = MinHeap() distances = {} # add the starting vertices to the runners runners.add( 0,(start,start)) while runners and dest not in reached: (val,(prev, goal)) = runners.pop_min() #print('[',prev,goal,val,']') if goal in reached: continue if goal not in reached: reached[goal] = prev distances[goal] = val # check the neighbours and add to the runners for succ in graph.neighbours(goal): runners.add( val + cost(goal,succ),(goal, succ)) if goal == dest: break # return empty list if dest cannot be reached if dest not in reached: return [] path = [] vertice = dest while True: path.append(vertice) #print(path) if path[-1] == start: break vertice = reached[vertice] # reverse list and output it path.reverse() return path
def setUp(self): self.heap = MinHeap()
def test_heap(): """Pytest fixture.""" heap = MinHeap() for _ in range(MAX_ITER): heap.insert(randint(0, 100)) return heap
class TestMinHeap(unittest.TestCase): def setUp(self): self.heap = MinHeap() def test_basic_initialization_and_repr(self): self.assertEqual(repr(self.heap), '[]') def test_insert(self): self.heap.insert(4) self.assertEqual(repr(self.heap), '[4]') self.assertEqual(self.heap.size, 1) self.heap.insert(4) self.assertEqual(repr(self.heap), '[4, 4]') self.assertEqual(self.heap.size, 2) self.heap.insert(6) self.assertEqual(repr(self.heap), '[4, 4, 6]') self.assertEqual(self.heap.size, 3) self.heap.insert(1) self.assertEqual(repr(self.heap), '[1, 4, 6, 4]') self.assertEqual(self.heap.size, 4) self.heap.insert(3) self.assertEqual(repr(self.heap), '[1, 3, 6, 4, 4]') self.assertEqual(self.heap.size, 5) def test_get_min(self): self.assertEqual(self.heap.get_min(), None) self.heap.insert(4) self.assertEqual(self.heap.get_min(), 4) self.heap.insert(7) self.assertEqual(self.heap.get_min(), 4) self.heap.insert(2) self.assertEqual(self.heap.get_min(), 2) self.heap.insert(-1) self.assertEqual(self.heap.get_min(), -1) def test_extract_min(self): self.heap.insert(4) self.heap.insert(5) self.heap.insert(7) self.heap.insert(2) self.heap.insert(-1) self.assertEqual(self.heap.extract_min(), -1) self.assertEqual(self.heap.extract_min(), 2) self.assertEqual(self.heap.extract_min(), 4) self.assertEqual(self.heap.extract_min(), 5) self.assertEqual(self.heap.extract_min(), 7) self.assertEqual(self.heap.extract_min(), None) def test_build_heap(self): self.heap.build_heap([4, 4, 6, 1, 3]) self.assertEqual(repr(self.heap), '[1, 3, 6, 4, 4]')
from heap import MinHeap from random import randint from time import clock # TODO use my mergesort for comparison? fill = [] for i in range(30): x = randint(0,10000) fill.append((x,x)) test = MinHeap(fill) print(test.heap) res = [] for i in range(test.size): res.append(test.pop()[1]) print(test.heap) fill.sort(key=lambda tup : tup[0]) res2 = list(map(lambda x : x[0], fill)) print("Expect:",res2) print("Get: ",res) print("Now for excitement!") heapElapsed = 0 listElapsed = 0 err = False for i in range(10000): fill = [] for i in range(100): x = randint(0,10000)
from heap import MinHeap, MaxHeap from math import floor import sys #invariant: maintain min heap size = floor(n/2), median is the the max in max heap with open('Median.txt') as f: #with open('median10_test.txt') as f: a = [int(l) for l in f] minHeap = MinHeap([]) maxHeap = MaxHeap([]) medians = [] for i in range(len(a)): if minHeap.size() == 0 and maxHeap.size() == 0: maxHeap.insert(a[i]) else: if a[i] < maxHeap.top(): maxHeap.insert(a[i]) else: minHeap.insert(a[i]) if minHeap.size() > floor((i+1)/2): maxHeap.insert(minHeap.extract()) elif minHeap.size() < floor((i+1)/2): minHeap.insert(maxHeap.extract()) medians.append(maxHeap.top()) print(sum(medians)%10000)
def __init__(self, percentile): self.percentile_tracked = percentile self.lheap = MaxHeap() self.rheap = MinHeap() self.size = 0 self.percentile = None