As part of the development of the DataStructures101 gem, I recently added a binary Heap implementation to the codebase.

A heap is a specialized tree-based structure that holds the following property true: *the key of a parent node is always, either less than or equal (in a min heap) or greater than or equal (in a max heap), than any of its children*.

The heap structure is very well known and has a lot of applications, among the most commons being the underlying implementation of a *Priority-Queue* and part of the *HeapSort* algorithm.

## Heap #

A binary Heap can be viewed both as a nearly complete binary tree or as an array, as shown in the figures below.

Each node of the three corresponds with an element of the array. The lines in the array show the parent-child relationship with the parent always at the left side.

Using an array-based implementation, we can express the heap property in the following way:

$$ A[Parent(i)] \le A[i] \quad for \ a \ \textbf{min-heap} $$

$$ A[Parent(i)] \ge A[i] \quad for \ a \ \textbf{max-heap} $$

### Operations #

The most important operations involving heaps are:

- Build-Heap: Operation to create a heap out of a given array of values.
*O(n)* - Insert (Push): Adds a new key to the heap. As part of the execution of this operation, it could cause the heap to violate the heap property and thus, the data structure must be rebalanced.
*O(log n)* - Extract-Max, Extract-Min (Pop): Removes the root of the heap, which is either the min (or max) element in the heap. Requires as well a rebalance of the heap.
*O(log n)* - Merge: Combines to heap to form a valid new heap containing all the elements of the original two.
*O(n), where n is the size of larger heap*

## Implementation #

Our `Heap`

class will support both *max_heap* and *min_heap*. It will do so by keeping the heap property as a lambda defined (`@heap_check`

) in the constructor based on the value min_heap flag:

`class Heap`

attr_reader :min_heap

def initialize(*args, min_heap: false)

@data = args

@min_heap = min_heap

@heap_check = ->(i, j) { return @data[i] >= @data[j] }

if min_heap

@heap_check = ->(i, j) { return @data[i] <= @data[j] }

end

build_heap

end

As it is shown in the `initialize`

method, the Heap construction finishes with the `build_heap`

operation, which will construct the heap in-place by applying `heapify`

recursively, as it can be seen in the code below. Notice that `build_heap`

avoids calling heapify on the second half of the `data`

array because a single node by itself holds valid the heap property.

` def build_heap`

start = @data.length / 2

start.downto(0) { |i| heapify(i) }

end

def heapify(i)

l = left(i)

r = right(i)

head = i

head = l if l < @data.size && @heap_check.call(l, head)

head = r if r < @data.size && @heap_check.call(r, head)

if head != i

@data[i], @data[head] = @data[head], @data[i]

heapify(head)

end

end

The `left`

and `right`

methods provide the children position of node in the array using 0-based indexing. Associated with them, `parent`

method allows to obtain the parent node in the array. These methods are implemented as follows:

` def left(i)`

2 * i + 1

end

def right(i)

2 * (i + 1)

end

def parent(i)

(i - 1) / 2

end

The following operations let the heap behave as a priority queue. The `push`

operation allows to insert new values into the heap, and will guarantee that the heap maintains its property after each insertion, by applying the `upheap`

method to the corresponding new inserted value. This will move the value up in the heap to its right location. On the other hand, the `pop`

operation removes the top element of the heap (either min or max) and will force a `heapify`

operation to re-establish the heap invariant, by buckle down to the right location the temporary last value that was set to replace the top of the heap.

` def push(*values)`

values.each do |val|

@data.push(val)

upheap(@data.size - 1)

end

self

end

def pop

result = @data.first

@data[0] = @data.pop

heapify(0)

result

end

### Complete version #

Combining all the code explained above, the final version of the heap implementations is as follow:

`class Heap`

attr_reader :min_heap

def initialize(*args, min_heap: false)

@data = args

@min_heap = min_heap

@heap_check = ->(i, j) { return @data[i] >= @data[j] }

if min_heap

@heap_check = ->(i, j) { return @data[i] <= @data[j] }

end

build_heap

end

def size

@data.size

end

def [](i)

@data[i]

end

def push(*values)

values.each do |val|

@data.push(val)

upheap(@data.size - 1)

end

self

end

def pop

result = @data.first

@data[0] = @data.pop

heapify(0)

result

end

def merge(heap)

new_array = @data + heap.instance_variable_get(:@data)

Heap.new(new_array, min_heap: self.min_heap)

end

def left(i)

2 * i + 1

end

def right(i)

2 * (i + 1)

end

def parent(i)

(i - 1) / 2

end

private

def build_heap

start = @data.length / 2

start.downto(0) { |i| heapify(i) }

end

def heapify(i)

l = left(i)

r = right(i)

head = i

head = l if l < @data.size && @heap_check.call(l, head)

head = r if r < @data.size && @heap_check.call(r, head)

if head != i

@data[i], @data[head] = @data[head], @data[i]

heapify(head)

end

end

end

## Conclusions #

With this post, we went over a simple Heap implementation in Ruby for the DataStructures101 gem. As part of the discussion, we mentioned what the *heap property* is and the most common operations a heap should support.

Then we analyzed a simple implementation of Heap in Ruby and provided some comments about the methods behavior. Finally we concluded with an overview of the final implementation.

Thank you so much for reading this post. Hope you liked reading it as much as I did writing it. Stay tuned for more!!