Min/Max Heap Visualization — Step by Step

A complete tree that lives in an array

A heap is a binary tree with a strict *shape* rule: every level is completely full except possibly the last, which fills left to right. That completeness means the tree can live in a plain array with no pointers at all. The node at index i has children at 2i + 1 and 2i + 2, and its parent at ⌊(i − 1) / 2⌋. Moving up or down the tree is pure index arithmetic — no allocation, cache-friendly, and impossible to unbalance. The visualizer draws the familiar tree shape, but keep in mind that underneath, the entire structure is just an array being indexed cleverly.

The heap property: ordered, but only vertically

The second rule is the heap property: in a max-heap every parent is greater than or equal to its children; a min-heap is the mirror image. Crucially, that is the *only* ordering. Siblings have no relationship, and a node deep in the left subtree may exceed everything in the right subtree. So a heap is emphatically not sorted — it guarantees exactly one thing globally: the root is the maximum (or minimum). That deceptively weak guarantee, maintained in O(log n) per operation, is precisely what a priority queue needs, and asking a heap for anything more than its root is asking the wrong structure.

Insert: sift up

Insertion appends the new value at the end of the array — the only position that keeps the tree complete — then repairs the heap property by sifting up. Compare the value with its parent and swap while it beats the parent: bigger in a max-heap, smaller in a min-heap. The value climbs its ancestor chain until a parent wins or it reaches the root. Because a complete tree of n nodes has height ⌊log₂ n⌋, this costs at most O(log n) swaps, and usually far fewer. The visualizer's demo inserts every input value one at a time, so you can watch each sift-up play out swap by swap.

Extract: sift down

Extraction always removes the root — the extreme element. But the shape rule says the *last* array slot is the one that must disappear, so: save the root, move the last element into index 0, shrink the array, then sift down. The displaced value repeatedly swaps with its larger child (in a max-heap) until both children are smaller or it hits the bottom — again O(log n). The demo runner inserts all values and then extracts every single one, and the extracted roots come out in sorted order. That is no coincidence; it is heapsort in embryo, as the last section shows.

Build-heap: O(n), surprisingly

Turning an arbitrary array into a heap does not require n separate inserts. Bottom-up heapify starts at the last internal node — index ⌊n/2⌋ − 1 — and sifts down each node, moving backward to the root. The leaves, which make up half the array, need no work at all. The total cost is O(n), not O(n log n): most nodes sit near the bottom with almost nothing below them to sift through, and summing (nodes per level × height below that level) converges to a constant times n. This linear build step is what makes heapsort's setup free, and it is a classic interview question in its own right.

Heapsort and priority queues

Two famous applications fall straight out of these operations. Build a max-heap, then repeatedly swap the root with the last element of a shrinking prefix and sift down: the array sorts itself in place, largest values settling at the end — heapsort, O(n log n) worst case with O(1) extra space. Even more important in practice is the priority queue: a heap of pending items where you always pop the most urgent one next. That single abstraction powers Dijkstra's shortest paths, operating-system schedulers, event-driven simulation, Huffman coding, and top-k queries over streams. Whenever code needs 'the best remaining item, with inserts at any time,' a heap is the answer.

JavaScript

function siftUp(a, i) {
  while (i > 0) {
    const parent = (i - 1) >> 1;
    if (a[parent] >= a[i]) break;
    [a[parent], a[i]] = [a[i], a[parent]];
    i = parent;
  }
}

function siftDown(a, i) {
  while (true) {
    let largest = i;
    if (2 * i + 1 < a.length && a[2 * i + 1] > a[largest]) largest = 2 * i + 1;
    if (2 * i + 2 < a.length && a[2 * i + 2] > a[largest]) largest = 2 * i + 2;
    if (largest === i) break;
    [a[i], a[largest]] = [a[largest], a[i]];
    i = largest;
  }
}

function insert(heap, value) {
  heap.push(value);
  siftUp(heap, heap.length - 1);
}

function extractMax(heap) {
  const max = heap[0];
  const last = heap.pop();
  if (heap.length > 0) {
    heap[0] = last;
    siftDown(heap, 0);
  }
  return max;
}

Python

def sift_up(a, i):
    while i > 0:
        parent = (i - 1) // 2
        if a[parent] >= a[i]:
            break
        a[parent], a[i] = a[i], a[parent]
        i = parent

def sift_down(a, i):
    n = len(a)
    while True:
        largest = i
        left, right = 2 * i + 1, 2 * i + 2
        if left < n and a[left] > a[largest]:
            largest = left
        if right < n and a[right] > a[largest]:
            largest = right
        if largest == i:
            break
        a[i], a[largest] = a[largest], a[i]
        i = largest

def insert(heap, value):
    heap.append(value)
    sift_up(heap, len(heap) - 1)

def extract_max(heap):
    maximum = heap[0]
    last = heap.pop()
    if heap:
        heap[0] = last
        sift_down(heap, 0)
    return maximum

Java

import java.util.ArrayList;
import java.util.List;

class MaxHeap {
    private final List<Integer> a = new ArrayList<>();

    void insert(int value) {
        a.add(value);
        int i = a.size() - 1;
        while (i > 0 && a.get((i - 1) / 2) < a.get(i)) { // sift up
            swap((i - 1) / 2, i);
            i = (i - 1) / 2;
        }
    }

    int extractMax() {
        int max = a.get(0);
        a.set(0, a.get(a.size() - 1));
        a.remove(a.size() - 1);
        int i = 0;                                       // sift down
        while (true) {
            int largest = i, l = 2 * i + 1, r = 2 * i + 2;
            if (l < a.size() && a.get(l) > a.get(largest)) largest = l;
            if (r < a.size() && a.get(r) > a.get(largest)) largest = r;
            if (largest == i) break;
            swap(i, largest);
            i = largest;
        }
        return max;
    }

    private void swap(int i, int j) {
        int t = a.get(i); a.set(i, a.get(j)); a.set(j, t);
    }
}