Right now I’m kinda deep into data structures and algorithms, learning by building some stuffs. Along the way I will be writing about what I learn → heaps, trees, bloom filters, storage engines, and anything that comes up.

If something I wrote is wrong, please, notify me. That’s how I get better.

GitHub · LinkedIn

So, I have been working on a project and it has been kinda cool, learning new stuffs, challenging and all. The project is about a real time location processing system. So, I encountered this problem, let us say some data came in for vehicles.

Data came in different order. Influenced by a lot of factors. Network among the reasons which causes increased latency and also, spatial indexing, organizing our geometric data so location based queries run fast, is irrelevant, if the data is out of chronological order. We cannot build an accurate picture of where vehicles are right now if we are processing events from the past mixed with events from the present. Chaos will surely ensue at some point.

So we need a mechanism to re sequence our data.

Upon consulting Gemini, I learnt there is a data structure for exactly this. But, I am kind of a noob to it.

Well, that is how I came to learn about heaps. Went on YT and hello interview to study it, that’s where I came across this course by AbdulBari on it (That man is the real OG). When he was explaining, he made mention that a heap is a complete binary tree.

The knowledge of my DSA class last semester on Binary Trees flooded back and it really came in handy. Although it was mostly theory based.

So what is a complete binary tree? First, a binary tree is a tree data structure where each node has at most two children. A complete binary tree is a special type of it where every level of the tree is filled but possibly with the exception of the last level which is filled from left to right.

There are actually two types of heap. We have the min heap and we have the max heap.

Let us visualize the heap as a tree. Say we have this min heap:

          1 (Root)
        /   \
       2     4
      / \   /
     5   8 6

This particular heap is a min heap because if we notice:

1. The smallest value is the root node
2. The parent of each node is less than either of its children

And for a max heap, we have this example:

          9 (root)
        /   \
       8     5
      / \   /
     4   6 2

It can be represented as an array. From the min heap tree above, we get:

[1, 2, 4, 5, 8, 6]

So how do we translate the tree into an array?

Label each node by level, from left to right: 0, 1, 2, 3, and so on. Then place each value at its labeled position in the array. Simple.

Here is the min-heap tree from above as an array:

When stored as a flat array, how do we know which node is whose child? Three formulas:

These formulas are what make the heap work without pointers. No left/right child fields. No object overhead. Just an array and math.

For my project use case: events have timestamps. Earlier timestamps must be processed before later ones. This is exactly what a min-heap gives us, the smallest timestamp always sits at index 0, ready to be extracted next.

The two operations that keep the heap working are:

• heapifyUp() → bubble a value up after insertion
• heapifyDown() → bubble a value down after extraction

Interactive Heap Visualizer

Play with the min-heap below. Insert values and extract the minimum. Watch how the tree rearranges itself.

Insert: Adding an Event to the Heap

So how do we add a new event to this thing?

We put it at the end of the array. That is step one. Just append, NB, we fill from left to right as usual.

But now the heap property might be broken. The new value might be smaller than its parent. And if the parent is bigger than the child, we have violated the min-heap rule. So we fix it.

We compare the new value with its parent. If the child is smaller, we swap them. Then we compare again with the new parent. We keep doing this until either the child is not smaller than the parent, or we reach the root.

This process is called bubble up or heapify up. It is the same idea every time. Compare. Swap if needed. Move up. Repeat.

Try inserting some values using the visualizer above. Watch how they bubble up. Try inserting a value smaller than the current root, it will travel all the way to the top. That is the worst case. That is O(log n) swaps.

ExtractMin: Getting the Next Event in Order

We have been adding events. Now we need to process them. The whole point of a min-heap is that the smallest value sits at the root. Always. So to get the next event in chronological order, we just look at index 0.

But we also need to remove it. And this removal is quite trickier than insertion.

We save the root value. That is what we return. Then we take the last element in the array, the rightmost leaf, and we move it to the root position.

Now the heap property is definitely broken. The value that was at the bottom is now at the top. It is probably bigger than one or both of its children.

So we bubble it down. We compare it with both children. If one of the children is smaller, we swap with the smaller child. Then we repeat from that child position. We keep going until the value is smaller than both its children, or it reaches a leaf with no children.

This is called bubble down or heapify down.

Try extracting the minimum a few times using the visualizer above and watch the bubble down:

The Implementation in Java

I think we’ve had enough theory. Here is the actual code.

The EventHeap Class

 1package com.rtlis.core.temporal;
 2
 3import com.rtlis.core.model.Point;
 4
 5public class EventHeap {
 6    private Point[] heap;
 7    private int size;
 8    private int capacity;
 9
10    public EventHeap(int capacity) {
11        this.capacity = capacity;
12        this.heap = new Point[capacity];
13        this.size = 0;
14    }
15}

This contains an array of Point objects. A size counter so we know how many elements are actually in the heap. A fixed capacity because this heap lives in memory and we do not want it growing forever. When it fills up, we flush it to disk and start a new one.

The Point Class

Before we get into the operations, here is the Point class that EventHeap stores:

 1package com.rtlis.core.model;
 2
 3public class Point {
 4    private double latitude;
 5    private double longitude;
 6    private long timestamp;
 7
 8    public Point(double latitude, double longitude, long timestamp) {
 9        this.latitude = latitude;
10        this.longitude = longitude;
11        this.timestamp = timestamp;
12    }
13
14    public long getTimestamp() {
15        return timestamp;
16    }
17
18    public double getLatitude() {
19        return latitude;
20    }
21
22    public double getLongitude() {
23        return longitude;
24    }
25
26    @Override
27    public String toString() {
28        return "Point{lat=" + latitude + ", lon=" + longitude + ", ts=" + timestamp + "}";
29    }
30}

Each Point holds a location and a timestamp. The timestamp is what the heap compares, the latitude and longitude are the actual vehicle position we care about once events are processed in order.

Insert

1public void insert(Point p) {
2    if (size == capacity) throw new IllegalStateException("Heap is full");
3
4    heap[size] = p;
5    size++;
6    heapifyUp(size - 1);
7}

Put the new element at the end. Increment size. Then call heapifyUp starting from that new element index. That is it. The real work happens in heapifyUp.

heapifyUp

 1private void heapifyUp(int index) {
 2    while (index > 0) {
 3        int parentIndex = (index - 1) / 2;
 4
 5        if (this.heap[index].getTimestamp() >= this.heap[parentIndex].getTimestamp()) {
 6            break;
 7        }
 8
 9        swap(index, parentIndex);
10        index = parentIndex;
11    }
12}

Line by line explanation:

• while (index > 0) means keep going until we reach the root. The root has index 0 and no parent.
• int parentIndex = (index - 1) / 2 is integer/floor division that gives us the parent index automatically. Remember the formula from the table above.
• The if check: if the current timestamp is greater than or equal to the parent timestamp, the heap property is satisfied. We stop.
• Otherwise, we swap the two elements and move our attention to the parent old position. Then we check again from there.

extractMin

(similar to pop operation in stack, remove and return)

 1public Point extractMin() {
 2    if (size == 0) return null;
 3
 4    Point min = heap[0];
 5    heap[0] = heap[size - 1];
 6    heap[size - 1] = null;
 7    size--;
 8
 9    if (size > 0) heapifyDown(0);
10
11    return min;
12}

Line by line explanation:

• if (size == 0) return null → nothing to extract if the heap is empty.
• Point min = heap[0] → we save the root because that is the minimum value and we need to return it.
• heap[0] = heap[size - 1] → move the last element to the root position.
• heap[size - 1] = null → clear the old last slot so the garbage collector can reclaim it.
• size-- → shrink the heap.
• if (size > 0) heapifyDown(0) → if the heap is not empty after removal, repair the heap starting from the root.

heapifyDown

 1private void heapifyDown(int index) {
 2    while (true) {
 3        int leftChild = 2 * index + 1;
 4        int rightChild = 2 * index + 2;
 5        int smallest = index;
 6
 7        if (leftChild < size && heap[leftChild].getTimestamp() < heap[smallest].getTimestamp()) {
 8            smallest = leftChild;
 9        }
10
11        if (rightChild < size && heap[rightChild].getTimestamp() < heap[smallest].getTimestamp()) {
12            smallest = rightChild;
13        }
14
15        if (smallest == index) break;
16
17        swap(index, smallest);
18        index = smallest;
19    }
20}

This one is longer but the idea is the same as heapifyUp, just going down instead of up.

Line by line explanation:

• int leftChild = 2 * index + 1 and int rightChild = 2 * index + 2 → get the children indices using the formula from earlier.
• int smallest = index → we start by assuming the current node is the smallest.
• Check left child: if it exists and its timestamp is smaller, it becomes the new candidate for smallest.
• Check right child: same thing. If it exists and is smaller than whatever is currently smallest, it becomes the new candidate.
• if (smallest == index) break → if after checking both children, the current node is still the smallest, we are done. Heap property is satisfied.
• Otherwise, swap with the smaller child and continue the loop from that child position.

The Swap Helper

1private void swap(int i, int j) {
2    Point temp = heap[i];
3    heap[i] = heap[j];
4    heap[j] = temp;
5}

Nothing fancy. Just exchanging two array positions. Pull out one value, store it temporarily, overwrite it with the other, then put the temporary value where the other one was.

So, How does this matter to my project

So why did I build this instead of just sorting an array?

Because events arrive continuously. Vehicles keep pinging. I cannot wait until I have all the events and then sort them. That would mean no processing happens until the system stops receiving data. And a real-time system never stops receiving data.

The heap gives me two operations that are both fast:

• Insert is O(log n). When a new event arrives, it takes at most log n comparisons to put it in the right place.
• ExtractMin is O(log n). When I need the next event in chronological order, I pop the root and repair the heap in (log n) time.

If I used a sorted array, insert would be O(n) because I would have to shift elements to make space. If I used an unsorted array, extractMin would be O(n) because I would have to scan the entire array for the minimum.

The heap is the sweet spot. Both operations are logarithmic. For a stream of millions of events, I think that is what makes the difference between a system that keeps up and a system that falls behind.

And when the heap fills up? I flush all the sorted data to an SSTable on disk and start a new heap. But that is a story for another day.

Thank you for reading ❤️. Ahmad Adewumi.

• No cookies
• No analytics scripts that identify you
• No third-party services collecting your data
• No comment system storing your information

The only analytics I use are Cloudflare Web Analytics, which is privacy-first and does not use cookies or fingerprinting. It tells me “someone visited this page” - nothing more.

This is a static site. There’s no database, no login system, no way for me to track individual visitors even if I wanted to.