Esempio n. 1
0
    def test_create_many(self):
        def is_invariant_node(i, my_heap):
            if i < 0 or i >= my_heap.size:
                raise IndexError(f"Index i should be between [0 and {my_heap.size})")
            if i != 0:
                pt = (i - 1) // 2
                if my_heap.arr[pt] < my_heap.arr[i]:
                    return False
            lf, rt = 2*i + 1, 2*i + 2
            if lf >= my_heap.size:
                return True
            elif rt == my_heap.size:
                if my_heap.arr[lf] > my_heap.arr[i]:
                    return False
            else:
                if my_heap.arr[i] < max(my_heap.arr[lf], my_heap.arr[rt]):
                    return False
            return True

        def check_heap_inv(my_heap):
            is_invariant = True
            for i in range(my_heap.size):
                is_invariant = is_invariant and is_invariant_node(i, my_heap)
            return is_invariant

        n_cases = 100
        n_nums = 50
        for _ in range(n_cases):
            num_list = list(np.random.rand(n_nums))
            h = Heap(num_list)
            self.assertTrue(check_heap_inv(h), "Heap invariant check failed")
Esempio n. 2
0
def heapsort(arr):
    """ Implements heapsort
    
        O(n*log(n))
    """
    heap = Heap(arr)
    for i in range(heap.size - 1, 0, -1):
        heap.heap[0], heap.heap[heap.size - 1] = heap.heap[heap.size -
                                                           1], heap.heap[0]
        heap.size -= 1
        heap.max_heapify(0)
    return heap.heap  # Ordered array
Esempio n. 3
0
def heap_sort(num_arr):
    """
    Returns num_arr sorted in ascending fashion. The original array is not modified.
    Sorting is implemented using heap sort algorithm.
    The algorithm has O(n * log(n)) complexity.
    How it works: The array is put into max heap. The root of max heap is always the largest number. The sorting is done
        by repeated popping of the root.
    This implementation does not conserve the order of equal elements ("unstable sort").
    """
    hp = Heap(num_arr)
    result = []
    while not hp.is_empty():
        result.insert(0, hp.pop_max())
    return result
Esempio n. 4
0
 def test_create(self):
     num_list = [1, 4, 7, 5, -3, 2, 8, 9]
     h = Heap(num_list)
     result = [9, 5, 8, 4, -3, 2, 7, 1]
     self.assertTrue(h.arr == result, f"Heap construction failed {h.arr}")