def extract_max(S): "Remove and return the element of S with largest key - O(lg n)" if S.heap_size < 1: raise Exception("Trivial heap") max, S[0] = S[0], S[S.heap_size - 1] S.heap_size -= 1 max_heapify(S, 0) return max
def heap_extract_max(a): if len(a) < 1: return 'error: heap underflow' max = a[0] a[0] = a[len(a) - 1] a.pop() heap_sort.max_heapify(a, 0) return max
def extract_max(heap): if heap.heap_size < 1: raise HeapUnderflowException mx = heap.at(0) lst = heap.heap_size - 1 heap.put(0, heap.at(lst)) heap.heap_size -= 1 del heap.array[lst] # not totally necessary hs.max_heapify(heap, 0) return mx
def extract_max(self): if self.heap_size()<1: raise "heap underflow" maxnum=self.queue[1] self.queue[1]=self.queue[self.heap_size()] self.queue.pop() # self.heap_size -= 1 heap_size=self.heap_size() max_heapify(self.queue,1,heap_size) return maxnum
def heap_extract_max(array, heap_size): if heap_size < 1: raise ValueError max_value = array[0] array[0] = array[heap_size - 1] del array[heap_size - 1] heap_size -= 1 max_heapify(array, heap_size, 0) return max_value
def heap_extract_max(arr): n = len(arr) build_max_heap(arr) #print n if n < 0: return 'Heap Underflow' max = arr[0] arr.remove(max) n = len(arr) max_heapify(arr, n, 0) return max
def delete(S, i): """ Deletes the item at node i. Delete is done in 2 steps: 1. Increase the element at i to infinity using increase_key(). This bring S[i] to the root of the max heap. 2. Replace the root with the last leaf in the heap. Decrement heap size by 1 and apply max_heapify() This fixes the gap that is left in the subtree where S[i] is the root - O(lg n) """ increase_key(S, i, float("inf")) S[0] = S[S.heap_size - 1] S.heap_size -= 1 max_heapify(S, 0)
def extract_max(A): if len(A) < 1: return [] max = A[0] A[1] = A[-1] A = A[:-1] A = max_heapify(A,0) return max,A
def runTest(self) : heap_sort.max_heapify( self.values[ 0 ], 1, len( self.values[ 0 ] )) self.assertEqual( self.values[ 0 ], self.expected[ 0 ], "not passed")
def test_not_max_heap_before(self): self.array = [1,2,3] self.assertEqual(heap_sort.max_heapify(self.array,0),[3,2,1])
def test_already_max_heap(self): self.array = [3,2,1] self.assertEqual(heap_sort.max_heapify(self.array,0),self.array)
def test_height2_not_max_heapify_before(self): self.array = [5,3,9,2,1,4,6] self.assertEqual(heap_sort.max_heapify(self.array,0),[9,3,6,2,1,4,5])
def test_max_heapify_for_even_count_of_nums(self): self.assertEqual([3, 6, 5, 1, 0, 9], max_heapify([3, 1, 5, 6, 0, 9], 2))
def test_max_heapify_for_bigger_sample_with_inner_pos(self): nums = [16, 4, 10, 14, 7, 9, 3, 2, 8, 1] self.assertEqual(nums, max_heapify(nums, 4))
def test_max_heapify_for_bigger_sample(self): nums = [16, 4, 10, 14, 7, 9, 3, 2, 8, 1] self.assertEqual([16, 14, 10, 8, 7, 9, 3, 2, 4, 1], max_heapify(nums, 2))