def heapSort(alist): """堆排序 O(nlogn)""" heap = BinHeap(len(alist)) heap.buildHeap(alist) sort = [] for i in range(len(alist), 0, -1): sort.append(heap.delMin()) return sort
def find_split(segments): """Finds an appropriate pair of segments that differ enough in timbre but also don't lie two near the beginning or the end.""" #initiate minimum binary heap instance deltas = BinHeap() #compares delta for each pair of segments (1,2), (2,3), etc... and save the values in deltas for i in range(len(segments)-2): deltas.insert((find_delta_segment(segments[i], segments[i+1]), i)) #take the largest difference a = deltas.delMin() #makes sure that a is not too near the beginning (before 1/6 of song) or #the end (after 5/6 of song) while a[1] < len(segments)//4 or a[1] > (3*len(segments))//4: a = deltas.delMin() return a
def heap_sort(my_list): sortlst = [] # create a list for sorted values heap = BinHeap() # create a heap heap.buildHeap(my_list) # build heap from an unsorted list while not heap.isEmpty(): # stop the loop when heap is empty sortlst.append( heap.delMin() ) # keep deleting the min value in the heap and reorganizing the heap and append the min value to sortlst return sortlst # return the sorted list
def heapSort(myList): # Create an empty heap minHeap = BinHeap() # Add all list items to minHeap minHeap.buildHeap(myList) # delMin heap items back to list in sorted order size = len(myList) for index in range(0, size): myList[index] = (minHeap.delMin())
class PriorityQueue(): """优先级队列""" def __init__(self, maxNode): self.priorityQueue = BinHeap(maxNode) self.dataDict = dict() def enqueue(self, priority, data): """入队""" self.priorityQueue.insert(priority) self.dataDict[priority] = data def dequeue(self): """出队""" pri = self.priorityQueue.delMin() return self.dataDict[pri]
class PriorityQueue: def __init__(self): self._heap = BinHeap() def isEmpty(self): return self._heap.isEmpty() def enqueue(self, item): self._heap.insert(item) def dequeue(self): return self._heap.delMin() def size(self): return self._heap.size() def __str__(self): return str(self._heap)
def dijkstra(vertice_list,src,num_ver): import CPUtimer timer = CPUtimer.CPUTimer() timer.reset() cond = False parent = [] #marca todos os vertices como nao visitados for i in range(num_ver): parent.append(-1) #vertice inicial tem distancia 0. Na 1 iteracao todos os demais estao setados com 'infinidade' vertice_list[src].dist=0 from binheap import BinHeap f = BinHeap() f.insert(vertice_list[src].dist,src) #print("Nodes:",f.total_nodes) #pelo numero de vertices, escolha o vertice de menor distancia atualmente no grafo. #Na primeira iteracao sera o source. i = 0 while(f.currentSize!=0): #while(i<10): i+=1 v_min_node = f.delMin() # 1.1 #print('key:',v_min_node.key) #print("Nodes:",f.total_nodes) v_min = vertice_list[v_min_node[1]] if(v_min==None): continue v_min.visited=1#marque vertice minimo como ja visitado. Desse modo o 1.2 sera feito, pois nao sera mais contado #para cada vertice adjacente ao vertice minimo for key in v_min.adjs:# 1.3 adj_ver = vertice_list[v_min.adjs[key].id]#pega o vertice adjacente #Se a distancia atual do vertice minimo, mais o seu peso, for menor que a distancia do vert adjacente if(adj_ver.visited==0 and v_min.dist + v_min.weights[key] < adj_ver.dist ): adj_ver.dist = v_min.dist + v_min.weights[key] #a distancia do vertice adjacente tera esse novo valor parent[adj_ver.id] = v_min.id # a pos que era do vertice adjacente, sera do menor v agora f.insert(adj_ver.dist,adj_ver.id)