Algorithms #10

Heaps

Lets start from the interview question

We have a list of points on the plane. Find the K closest points to the origin (0, 0).

(1; 1)

(3; 2)

(-0.3; -0.4)

(-2; -1)

Data = [[3, 2], [1,1], [-0.3, -0.4], [-2, -1]], k = 2

Res = [ [-0.3, -0.4], [1,1]], k = 2

Another question

Kth Largest Element in an Array

Given [3,2,1,5,6,4] and k = 2, return 5.

One of the possible solutions is using a Heap

Heap is a special case of balanced binary tree data structure where the root-node key is compared with its children and arranged accordingly.

What is a Heap ?

The maximum number of children of a node in a heap depends on the type of heap. However, in the more commonly-used heap type, there are at most children of a node and it's known as a Binary heap

Max-Heap: In a Max-Heap the key present at the root node must be greatest among the keys present at all of it’s children. The same property must be recursively true for all sub-trees in that Binary Tree.

Min-Heap: In a Min-Heap the key present at the root node must be minimum among the keys present at all of it’s children. The same property must be recursively true for all sub-trees in that Binary Tree.

Other types of heaps

When would I want to use a heap?

Whenever you need quick access to the largest (or smallest) item
Queues / Schedulers (where the earliest item is desired)
Heapsort: One of the best sorting methods being in-place and with no quadratic worst-case scenarios.
Selection algorithms: Finding the min, max, both the min and max, median, or even the k-th largest element
Graph algorithms: By using heaps as internal traversal data structures, run time will be reduced by polynomial order.

The complexity

A heap can be implemented using objects links (like we did for BST) and the Array!

<-- Figure out this!

Parent = (index-1)/2

Left child        index*2 + 1

Right child       index*2 + 2

Push algorithm

Place new element to the end of array
Find parent index
Check if parent element is on his place
Move recursively on top node or stop the execution.

class Heap {

	constructor() {
    	this.data = [];
        this.size = 0;
    }
    
    bubbleUp() { /* ... */ }
    
    put(val) { /* ... */ }
    
    print() { console.log(this.data) }

}

const heap = new Heap();
heap.push(20);
heap.push(10);
heap.push(30);
heap.push(1);
heap.push(100);
heap.print(); // [ 100, 30, 20, 1, 10 ]

Problem #1

Implement .push(val) method

Pop algorithm

Remove first item in array (and return it later)
Place last item of array to the first place
Check if left or right child is bigger than current node
Move down recursively until you all childs will be smaller than current node

}

Max-Heapify

Problem #2

Implement .pop() method

class Heap {

	constructor() {
    	this.data = [];
        this.size = 0;
    }
    
    bubbleUp() { /* ... */ }
    
    put(val) { /* ... */ }
    
    print() { console.log(this.data) }
    
    maxHeapify() { /* ... */ }
    
    pop() { /* ... */ }

}

Problem #3

Implement .buildMaxHeap(arr) method

class Heap {

    /* ... */
    
    buildMaxHeap(arr = []) { /* ... */ }

}

const heap = new Heap();

heap.buildMaxHeap([1,20,10,100,30]);


heap.print(); // [ 100, 30, 20, 1, 10 ]

Priority Queue

Applications of Priority Queue

Dijkstra's shortest path algorithm implementation can be done using priority queues.
A* Search algorithm implementation can be done using priority queues.
Priority queues are used to sort heaps.
Priority queues are used in operating system for load balancing and interrupt handling.
Priority queues are used in huffman codes for data compression.
In traffic light, depending upon the traffic, the colors will be given priority.

Problem #4

Refactor a Heap class, so you can use it as a priority queue

HeapSort

Heap sort is a comparison based sorting technique based on Binary Heap data structure. It is similar to selection sort where we first find the maximum element and place the maximum element at the end. We repeat the same process for remaining element.

Time Complexity: Time complexity of heapify is O(Log n). Overall time complexity of Heap Sort is O(n Log n).

Problem #5

Use Heap to sort an array

Thank you!