(min)Heap: buildHeap

Week 11, Monday

March 16, 2026

Announcements

• PA3 due Week 12

Review

This image reminds us of a _______________, which is one way we can implement ADT ___________________, whose functions include _____________ and _______________, with running times ____________________.

Heap (or complete binary tree with heap-order property). Priority queue. insert and remove_min. O(log n) each.

(min)Heap: buildHeap

The array spells BUILD HEAP NOW. W is at index 0 to emphasize this comes to us as a plain array. This is NOT a heap — it’s just an arbitrary array stored in a complete binary tree shape. The question is: how do we turn this into a valid min-heap?

(min)Heap: buildHeap — 3 alternatives

1. Sort the array

2.

def build_heap(self):
    for i in range(2, self.size + 1):
        self._heapify_up(i)

3.

def build_heap(self):
    for i in range(self._parent(self.size), 0, -1):
        self._heapify_down(i)

Three ways to build a heap from an arbitrary array. (1) Sort — gives a valid heap but costs O(n log n). (2) Repeated heapify_up from index 2 to size — also O(n log n). (3) Heapify_down from last parent down to root — this is O(n)! We’ll prove this next.

(min)Heap: buildHeap

Thm: The running time of buildHeap on an array of size \(n\) is ________.

Instead of focusing specifically on running time, we observe that the time is proportional to the sum of the heights of all of the nodes, which we denote by \(S(h)\).

\(S(h) = \underline{\hspace{8em}}\)

\(S(0) = \underline{\hspace{4em}}\)

\(\text{Soln } S(h) = \underline{\hspace{8em}}\)

Proof of solution to the recurrence:

Given: \(S(h) = 2S(h-1) + h, S(0) = 0\)

Show: \(S(h) = 2^{(h+1)} - h - 2\)

 

 

But running times are reported in terms of \(n\), the number of nodes…

S(h) = 2·S(h-1) + h. S(0) = 0. Solution: S(h) = 2^(h+1) - h - 2. Proof by induction. Since n = 2^(h+1) - 1, S(h) = n - h - 1 = n - log(n+1) = O(n). Therefore buildHeap (approach 3) runs in O(n), not O(n log n).

(min)Heap: heapSort

Running time?

•  

Why do we need another sorting algorithm?

•  

HeapSort: (1) buildHeap — O(n). (2) Repeatedly remove_min, placing each min at the end of the array — n times O(log n). (3) Total: O(n log n). Why another sort? HeapSort is in-place (no extra array needed, unlike merge sort) and worst-case O(n log n) (unlike quicksort). Trade-off: poor cache performance compared to quicksort in practice.