Merge pull request #60 from thakursaurabh1998/heap-add-thakursaurabh

minimum priority queue added under heap

Author: ms10398

Data Structures/Heap/MinPriorityQueue.js

@@ -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 ]