Secret Mystery ADT

Week 10, Wednesday

March 11, 2026

Announcements

• PEX4 available (trees)
• PA3 available (genomic intervals), due Week 12

Secret Mystery ADT

First: what types of data can you put into it?

Have students suggest types. Guide them: can you compare two of these? Which is “less than” the other? Integers? Yes. Kittens? No. Build intuition that this structure requires an ordering on its elements. The key insight: it requires comparable keys (like a BST, unlike a hash table).

The Mystery Bag

 

ADT: ______________

• insert
• remove
• size

“I have a mystery data structure. Let’s put things in!” Ask students to call out numbers. Write them on the bag as you “put them in.” e.g., students say 7, 3, 12, 1, 9. Then say: “Now, remove something.” Student says “remove 7.” You say: “SORRY! This structure doesn’t allow arbitrary removes. It gives you what IT wants!” You reach in and pull out… 1 (the smallest). Do it again: pull out 3. Students figure out: it always returns the minimum. Then fill in the blank: “Priority Queue.” Write in the operations: insert(key), removeMin(), size().

ADT: Priority Queue

insert(key) – add an element

remove_min() – remove and return the smallest element

size() – how many elements?

Where would you use this?

• Emergency room triage (most urgent patient first)
• Task scheduling (highest priority job first)
• Top-k trending from 500M tweets (don’t sort them all!)
• Dijkstra’s shortest path algorithm (coming soon!)

Connect to data science: “given 500 million tweets, find the top 10 trending” – you don’t need to sort all 500M, just track the top 10 efficiently.

Priority Queue: Implementations

First, work through the blank table at top using the array diagrams on the right. Unsorted: insert at end = O(1), remove_min scan for min = O(n). Sorted: insert needs shifting = O(n), remove_min from end = O(1). Then show the error table: “find the errors!” Students catch: unsorted remove_min can’t be O(1) — you have to scan! Sorted insert can’t be O(1) — you have to shift! After fixing, pose: “Can we do both in O(log n)?” The ??? row teases what comes next.

An Aside: A New Kind of Tree

Tell me everything you can about this structure.

 

•  
•  
•  
•  

Have students observe and make a list. Guide them to notice: 1. It’s a binary tree 2. It’s complete — filled level by level, left to right (no gaps!) 3. Every parent is smaller than (or equal to) its children 4. It is NOT a BST! (7 is a right child of 6, but 16 is a left child — no left < parent < right rule) 5. The smallest element is at the root. Colored by level.

After they’ve made their observations, say: “This structure is called a HEAP. Specifically, a min-heap.”

(Min-)Heap

Structure property: A complete binary tree – a perfect binary tree, but allowing nodes to be missing from the right side of the bottom level

Heap-order property: Every node’s key \(\leq\) its children’s keys

Recursive definition: A min-heap is either empty, or a node whose key is \(\leq\) the keys of its children, where both subtrees are also min-heaps.

A heap is not a BST!

• BST: left < parent < right (horizontal ordering)
• Heap: parent \(\leq\) children (vertical ordering only)

How would you implement this?

After defining the two properties, ask students to speculate on implementation. They’ll likely suggest nodes-and-pointers (like our BST). Nod and say “that would work, but…” hint at something better. “What if I told you we don’t need any pointers at all?” Build suspense for the next slide.

(Min-)Heap Implementation

This is the big reveal! The complete binary tree maps perfectly to an array via level-order traversal. Index 0 is unused (makes the math clean). Each level’s nodes are contiguous and color-coded to match the tree. Students should see the pattern: red = level 0 (1 node), orange = level 1 (2 nodes), green = level 2 (4 nodes), blue = level 3 (5 nodes). The empty cells at the end show the array’s capacity — room to grow! No pointers, no nodes — just an array. This is why the structure property (complete binary tree) is so important.

Navigating the Array

For a node at index i:

• Parent:
• Left child:
• Right child:

This is why we use 1-based indexing. With 0-based: parent = (i-1)//2, left = 2i+1, right = 2i+2. Messier. Test it on the example! Node 5 is at index 2: left(2)=4 → value 9. right(2)=5 → value 15. parent(2)=1 → value 4. Node 15 at index 5: parent(5)=2 → value 5. left(5)=10 → value 25. right(5)=11 → value 18. It all works!

(Min-)Heap insert

1. what would be an EASY key to insert?
2. how do we insert a smaller key?

Heap: insert Implementation

def insert(self, key):
    self.size += 1
    self.items[self.size] = key
    self._heapify_up(self.size)

def _heapify_up(self, i):
    if i > _____:
        p = parent(i)
        if self.items[i] ___ self.items[p]:
            self.items[i], self.items[p] = self.items[p], self.items[i]
            self._heapify_up(_____)

Running time of insert?

Fill in the blanks together. Base case: i > 1 (root has no parent). Comparison: items[i] < items[parent] (child smaller than parent violates heap order). Recursive call on parent index (the value bubbled up to parent’s position).

(Min-)Heap removeMin

1. what do we remove?
2. then what?

Heap: removeMin Implementation

def remove_min(self):
    min_val = self.items[1]
    self.items[1] = self.items[self.size]
    self.size -= 1
    self._heapify_down(1)
    return min_val

def _heapify_down(self, i):
    if has_child(i):
        mc = min_child(i)
        if self.items[i] ___ self.items[mc]:
            self.items[i], self.items[mc] = self.items[mc], self.items[i]
            self._heapify_down(_____)

Running time of removeMin?

Fill in blanks: comparison is > (parent bigger than min child). Recursive call on mc (the value sank down to the child’s position). Why min_child? Because we need the smaller child to become the parent to maintain heap order with the other child.

Summary

Implementation	insert	remove_min
Unsorted array	O(1)	O(n)
Sorted array	O(n)	O(1)
Heap	O(log n)	O(log n)

Neither array implementation can do both well. The heap gives us the best of both worlds. This is the same tradeoff we saw with BSTs vs unsorted/sorted arrays for dictionaries.

Heap Explorer

Live demo: insert a few values and watch the bubble-up. Then remove_min and watch the bubble-down. Point out the array at the bottom updating in sync with the tree.

Summary

• Priority Queue ADT: insert + remove_min
• Heap: a complete binary tree with the heap-order property
• Stored as an array (no pointers needed!)
• insert: add at end, bubble up – O(log n)
• remove_min: replace root with last, bubble down – O(log n)

Next time: How to build a heap from scratch (faster than you think!)