Priority Queue

// PriorityQueue<Integer> pq = new PriorityQueue<>();
public void insert(int[] heap, int size, int x) {
    int i = size;
    heap[i] = x;

    while (i > 0) {
        int p = (i - 1) / 2;
        if (heap[i] >= heap[p]) break;
        swap(heap, i, p);
        i = p;
    }
}

import heapq

# heapq is a MIN-heap out of the box
heapq.heappush(pq, x)

priority_queue<int, vector<int>, greater<int>> pq; // min-heap
pq.push(x);   // max-heap by default without greater<>

// No built-in heap — tiny binary-heap class
class MinHeap {
  push(x) {
    this.a.push(x);
    let i = this.a.length - 1;
    while (i > 0) {
      const p = (i - 1) >> 1;
      if (this.a[i] >= this.a[p]) break;
      [this.a[i], this.a[p]] = [this.a[p], this.a[i]];
      i = p;
    }
  }
}

public int extractMin(int[] heap, int size) {
    int min = heap[0];
    heap[0] = heap[size - 1];   // last fills the root hole
    siftDown(heap, 0, size - 1);
    return min;
}

void siftDown(int[] a, int i, int n) {
    while (true) {
        int l = 2*i + 1, r = 2*i + 2, s = i;
        if (l < n && a[l] < a[s]) s = l;
        if (r < n && a[r] < a[s]) s = r;
        if (s == i) return;
        swap(a, i, s);
        i = s;
    }
}

smallest = heapq.heappop(pq)

int smallest = pq.top(); pq.pop();

pop() {
  const top = this.a[0];
  const last = this.a.pop();
  if (this.a.length) {
    this.a[0] = last;
    let i = 0;
    for (;;) {
      const l = 2 * i + 1, r = l + 1;
      let s = i;
      if (l < this.a.length && this.a[l] < this.a[s]) s = l;
      if (r < this.a.length && this.a[r] < this.a[s]) s = r;
      if (s === i) break;
      [this.a[i], this.a[s]] = [this.a[s], this.a[i]];
      i = s;
    }
  }
  return top;
}