def __init__(self, graph): self.__mst = [] self.__pq = min_heap.MinHeap(graph.e()) self.__uf = union_find.UnionFind5(graph.v()) for i in range(graph.v()): adj = graph.adjIterator(graph, i) e = adj.begin() while not adj.end(): if e.v() < e.w(): self.__pq.insert(e) e = adj.next_item() while not self.__pq.is_empty() and len(self.__mst) < graph.v() - 1: e = self.__pq.extract_min() if self.__uf.is_connected(e.v(), e.w()): continue self.__mst.append(e) self.__uf.union(e.v(), e.w()) self.__mst_weight = self.__mst[0].wt() for i in range(1, len(self.__mst)): self.__mst_weight += self.__mst[i].wt()
def main(): count = int(input()) max_heap = maxh.MaxHeap() min_heap = minh.MinHeap() # put first element in one of the heap first = int(input()) second = int(input()) if first > second: max_heap.insert(second) min_heap.insert(first) else: max_heap.insert(first) min_heap.insert(second) # set the first median print first median = (first + second) / 2 print median for i in range(1, count - 1): this_num = int(input()) if this_num < max_heap.peek_max(): max_heap.insert(this_num) else: min_heap.insert(this_num) balance_heaps(max_heap, min_heap) print(get_median(max_heap, min_heap))
def dijkstra(G,source=0,trace=False): known = [False for i in range(len(G.al))] prev = [-1 for i in range(len(G.al))] dist =[math.inf for i in range(len(G.al))] dist_heap = min_heap.MinHeap() dist[source] = 0 dist_heap.insert(min_heap.HeapRecord(dist[source],source)) while len(dist_heap.heap)>0: heap_node = dist_heap.extractMin() v = heap_node.data if not known[v]: known[v] = True for edge in G.al[v]: u = edge.dest if not known[u]: w = edge.weight if dist[v]+w < dist[u]: prev[u] = v dist[u] = dist[v]+w dist_heap.insert(min_heap.HeapRecord(dist[u],u)) if trace: print('v=',v) print('known=',known) print('prev=',prev) print('dist=',dist) return prev, dist
def prims(graph, start): ''' Calculates the minimum spanning tree for a graph and return the minimum cost for the MST ''' # Initialize all the nodes of the graph as unvisited visited = {vertex: False for vertex in graph.adjacency_dict} pq = min_heap.MinHeap() # Mark the starting node as visited visited[start] = True # Put the starting node in the mst mst = [start] minimumCost = 0 # Insert all the edges from start to min heap for edge in graph.adjacency_dict[start]: pq.insert(edge) while (not all_visited(visited)): least_weighted_edge = pq.extract_min() # Extract the minimum value until we found one node that is not visited while (least_weighted_edge and visited[least_weighted_edge.dest]): least_weighted_edge = pq.extract_min() if least_weighted_edge: visited[least_weighted_edge.dest] = True mst.append(least_weighted_edge) minimumCost += least_weighted_edge.weight # For all the edges connected to the node, we put them in min heap for edge in graph.adjacency_dict[least_weighted_edge.dest]: pq.insert(edge) print minimumCost
def prim(G,origin=0, trace=False): weight_heap = min_heap.MinHeap() connected = set([origin]) for edge in G.al[origin]: weight_heap.insert(min_heap.HeapRecord(edge.weight,[origin,edge.dest,edge.weight])) mst = graph.Graph(len(G.al),weighted=True) count = 0 while count<len(G.al)-1 and len(weight_heap.heap)>0: next_edge = weight_heap.extractMin().data if next_edge[0] not in connected: new_vertex = next_edge[0] elif next_edge[1] not in connected: new_vertex = next_edge[1] else: continue mst.insert_edge(next_edge[0],next_edge[1],next_edge[2]) connected.add(new_vertex) count+=1 if trace: draw_over(G,mst,'Prim '+str(count)) print(next_edge,'added to mst') for edge in G.al[new_vertex]: if edge.dest not in connected: weight_heap.insert(min_heap.HeapRecord(edge.weight,[new_vertex,edge.dest,edge.weight])) if count == len(G.al)-1: return mst print('Graph has no minimum spanning tree') return None
def dijkstra(G, source): pred = { } #Predecessor dictionary. Isn't returned, but here for your understanding dist = {} #Distance dictionary Q = min_heap.MinHeap([]) nodes = list(G.adj.keys()) #Initialize priority queue/heap and distances for node in nodes: Q.insert(min_heap.Element(node, 99999)) dist[node] = 99999 Q.decrease_key(source, 0) #Meat of the algorithm while not Q.is_empty(): current_element = Q.extract_min() current_node = current_element.value dist[current_node] = current_element.key for neighbour in G.adj[current_node]: if dist[current_node] + G.w(current_node, neighbour) < dist[neighbour]: Q.decrease_key( neighbour, dist[current_node] + G.w(current_node, neighbour)) dist[neighbour] = dist[current_node] + G.w( current_node, neighbour) pred[neighbour] = current_node return dist
def kruskal(G,trace=False): weight_heap = min_heap.MinHeap() S = dsf.DSF(len(G.al)) for v in range(len(G.al)): for edge in G.al[v]: if v<edge.dest: weight_heap.insert(min_heap.HeapRecord(edge.weight,[v,edge.dest,edge.weight])) mst = graph.Graph(len(G.al),weighted=True) count = 0 while count<len(G.al)-1 and len(weight_heap.heap)>0: next_edge = weight_heap.extractMin().data if S.union(next_edge[0],next_edge[1])==1: mst.insert_edge(next_edge[0],next_edge[1],next_edge[2]) count+=1 if trace: draw_over(G,mst,'Kruskal '+str(count)) print(next_edge,'added to mst') else: if trace: print(next_edge,'rejected') if count == len(G.al)-1: return mst print('Graph has no minimum spanning tree') return None
def dijkstra(self): self.Q = min_heap.MinHeap([(v, self.d[v]) for v in self.vertices]) while self.Q.get_length() != 0: u = self.Q.extract_min() self.S.add(u) if u not in self.adj: self.adj[u] = set() for v in self.adj[u]: val = self.relax(u, v) if val != False: self.Q.decrease_key(v, val)
def __init__(self, graph): self.__g = graph self.__pq = min_heap.MinHeap(graph.e()) self.__marked = [False for _ in range(graph.v())] self.__mst = [] self.__visit(0) # print(self.__pq.size()) while not self.__pq.is_empty(): e = self.__pq.extract_min() if self.__marked[e.v()] and self.__marked[e.w()]: continue self.__mst.append(e) if not self.__marked[e.v()]: self.__visit(e.v()) else: self.__visit(e.w()) self.__mst_weight = self.__mst[0].wt() for i in range(1, len(self.__mst)): self.__mst_weight += self.__mst[i].wt()
def prims_mst(self): self.vertex[0].key = 0 # inserisco i nodi nella coda Q = min_heap.MinHeap() for i in self.vertex: Q.insert_heap(i) Q.heapify(0) while Q.heap: u = Q.extract_min() self.weight += u.key if u.parent is not None: self.mst.append([u.parent.name, u.name]) for i in range(0, len(self.vertex)): if self.graph[u.name][i] != 0: if self.vertex[i] in Q.heap and self.graph[u.name][i] < Q.heap[Q.heap.index(self.vertex[i])].key: Q.heap[Q.heap.index(self.vertex[i])].parent = u Q.decrease_key(self.vertex[i], self.graph[u.name][i])
print('Question 3') L = [2,4,6,11,13,3,1,12] H = htc.HashTableChain(9) for i in L: H.insert(i) H.print_table() remove_same_hash(H,1) H.print_table() remove_same_hash(H,22) H.print_table() print('Question 4') H = min_heap.MinHeap() for i in [4,8,9,14,5,11,7,3,6,10]: H.insert(i) H.draw() for i in range(len(H.heap)+2): print(i,sibling(H,i)) print('Question 5') A =[11, 6, 7, 16, 17, 2, 4, 18, 14, 8, 15,12] TA = bst.BST() for a in A: TA.insert(a) TA.draw()
return False if __name__=="__main__": plt.close('all') L0 = [1, 2, 3, 4, 5, 1] L1 = [i for i in range(10)] L2 = [2302] L3 = [] L4 = [1, 2, 3, 4, 5, 3] L5 = [2, 2] L6 = [ 2, 2, 1] print('-- is_heap') for L in [L0,L1,L2,L3,L4,L5,L6]: print(is_heap(L)) H1 = min_heap.MinHeap() for i in [4,8,2]: H1.insert(i) H1.draw() H2 = min_heap.MinHeap() for i in [4,8,9,14,5,7]: H2.insert(i) H2.draw() H3 = min_heap.MinHeap() for i in [4,6,11,8,9,14,5,0,3,7,4]: H3.insert(i) H3.draw() H4 = min_heap.MinHeap() for i in [5,0,3,7,8,9,14,4,6,8,9,14,5,6,7,6]: H4.insert(i)
def __init__(self): super().__init__() self.S = set() self.Q = min_heap.MinHeap(list())
h = build_index_table(L) h.print_table() ''' Table contents: bucket 0: [ ] bucket 1: [ [1, [3, 6]] ] bucket 2: [ [2, [0, 4]] ] bucket 3: [ [3, [5]] ] bucket 4: [ [4, [1]] [12, [7]] ] bucket 5: [ ] bucket 6: [ [6, [2]] ] bucket 7: [ ] ''' print('Question 4') H1 = min_heap.MinHeap() for i in [4, 8, 2, 6, 3]: H1.insert(i) H1.draw() H2 = min_heap.MinHeap() for i in [4, 8, 9, 14, 5, 7]: H2.insert(i) H2.draw() print(smallest_n(H1, H2, 5)) # [2,3,4,4,5] H1 = min_heap.MinHeap() for i in [24, 8, 22, 62, 3]: H1.insert(i) H1.draw() H2 = min_heap.MinHeap()
def build_tree(heap): while not heap.empty(): left = heap.pop(Cmp().cmp) right = heap.pop(Cmp().cmp) if left is not None and right is not None: heap.insert(Node(left.times + right.times, left, right), Cmp().cmp) elif left is None: return right elif right is None: return left def travel_tree(root, lst, bitstring=''): if type(root) == Letter: # python3 only root.bitstring = bitstring lst.append(root) return travel_tree(root.left, lst, bitstring + '0') travel_tree(root.right, lst, bitstring + '1') if __name__ == "__main__": heap = min_heap.MinHeap([]) parser_file(None, heap) root = build_tree(heap) lst = [] travel_tree(root, lst, '') for one in lst: one.dump()