A binary heap is a complete binary tree that satisfies the heap property: in a min-heap every parent is no larger than its children, and in a max-heap every parent is no smaller. Because the tree is complete, we can store it in a plain array and compute relationships arithmetically — for a node at index i (0-based), its children sit at 2i+1 and 2i+2 and its parent at floor((i-1)/2). This array trick is what makes heaps fast and memory-efficient, and it is the reason heaps are the standard implementation behind priority queues.
The operations you need to master are few but must be traced carefully. Insert places a new element at the end of the array and sifts it up while it violates the heap property; extract-min or extract-max removes the root, moves the last element into the root slot, and sifts down; heapify restores the property at a subtree, and repeated heapify from the middle of the array builds a heap from unordered data. Insert and extract run in O(log n), peeking at the root is O(1), and building a heap bottom-up is O(n).
As you watch, keep two questions in mind. First, at every swap, what are the index computations — which child is chosen for comparison, and why? Second, how does a heap compare to alternatives such as a sorted array, an unsorted array, or a balanced BST: a heap gives you cheap access to the extreme element but does not support fast arbitrary search or ordered traversal, which is exactly the trade-off that decides when to use one.
A compact walkthrough of the core heap methods — building a heap and the insert and extract routines that keep the heap property intact — presented step by step with accompanying Python code linked in the description. Expect to see the sift-up and sift-down movement of elements illustrated on a concrete example.
Michael Sambol's data structures series is known for short, precise animations that match textbook algorithms, and this one directly targets the insert, extract, and heapify subtopics with runnable code you can read afterward.
A longer, example-driven lecture that explains the heapify method and then uses it to drive heap sort, working through a full example by hand. Along the way it covers how elements are arranged and reorganized as the largest or smallest element is repeatedly removed from the root.
The slower pace and worked example are useful for practicing the trace-by-hand skill, and seeing heapify applied to sorting reinforces why building a heap and repeatedly extracting the root are the key cost drivers in heap performance.
Together these videos target MO3 most directly: both walk through insert, extract, and heapify on concrete examples so you can practice tracing operations and the parent/child index arithmetic of the array representation. The emphasis on sift-up and sift-down paths bounded by the height of a complete tree also supports MO1 and MO5, giving you the O(log n) and O(n) results you will need in order to argue when a heap is preferable to an AVL tree, a sorted array, or a trie for a priority-based task.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.