Skip to content

minimum priority queue added under heap #60

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
the-codingninja merged 1 commit into from
Oct 4, 2018
Merged

minimum priority queue added under heap #60

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
128 changes: 128 additions & 0 deletions Data Structures/Heap/MinPriorityQueue.js
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,128 @@

/* Minimum Priority Queue
* It is a part of heap data structure
* A heap is a specific tree based data structure
* in which all the nodes of tree are in a specific order.
* that is the children are arranged in some
* respect of their parents, can either be greater
* or less than the parent. This makes it a min priority queue
* or max priority queue.
*/

// Functions: insert, delete, peek, isEmpty, print, heapSort, sink

class MinPriorityQueue {

// calss the constructor and initializes the capacity
constructor(c) {
this.heap = [];
this.capacity = c;
this.size = 0;
}

// inserts the key at the end and rearranges it
// so that the binary heap is in appropriate order
insert(key) {
if (this.isFull()) return;
this.heap[this.size + 1] = key;
let k = this.size + 1;
while (k > 1) {
if (this.heap[k] < this.heap[Math.floor(k / 2)]) {
let temp = this.heap[k];
this.heap[k] = this.heap[Math.floor(k / 2)];
this.heap[Math.floor(k / 2)] = temp;
}
k = Math.floor(k / 2);
}
this.size++;
}

// returns the highest priority value
peek() {
return this.heap[1];
}

// returns boolean value whether the heap is empty or not
isEmpty() {
if (0 == this.size) return true;
return false;
}

// returns boolean value whether the heap is full or not
isFull() {
if (this.size == this.capacity) return true;
return false;
}

// prints the heap
print() {
console.log(this.heap.slice(1));
}

// heap sorting can be done by performing
// delete function to the number of times of the size of the heap
// it returns reverse sort because it is a min priority queue
heapSort() {
for (let i = 1; i < this.capacity; i++) {
this.delete();
}
}

// this function reorders the heap after every delete function
sink() {
let k = 1;
while (2 * k <= this.size || 2 * k + 1 <= this.size) {
let minIndex;
if (this.heap[2 * k] >= this.heap[k]) {
if (2 * k + 1 <= this.size && this.heap[2*k+1] >= this.heap[k]) {
break;
}
else if(2*k+1 > this.size){
break;
}
}
if (2 * k + 1 > this.size) {
minIndex = this.heap[2 * k] < this.heap[k] ? 2 * k : k;
} else {
if (
this.heap[k] > this.heap[2 * k] ||
this.heap[k] > this.heap[2 * k + 1]
) {
minIndex =
this.heap[2 * k] < this.heap[2 * k + 1] ? 2 * k : 2 * k + 1;
} else {
minIndex = k;
}
}
let temp = this.heap[k];
this.heap[k] = this.heap[minIndex];
this.heap[minIndex] = temp;
k = minIndex;
}
}

// deletes the highest priority value from the heap
delete() {
let min = this.heap[1];
this.heap[1] = this.heap[this.size];
this.heap[this.size] = min;
this.size--;
this.sink();
return min;
}
}

// testing
q = new MinPriorityQueue(8);

q.insert(5);
q.insert(2);
q.insert(4);
q.insert(1);
q.insert(7);
q.insert(6);
q.insert(3);
q.insert(8);
q.print(); // [ 1, 2, 3, 5, 7, 6, 4, 8 ]
q.heapSort();
q.print(); // [ 8, 7, 6, 5, 4, 3, 2, 1 ]