chapter 11: heap

Author: loiane

src/11-heap/01-min-heap.js

@@ -0,0 +1,43 @@
+// src/11-heap/01-min-heap.js
+
+const Heap = require('./heap');
+
+class Task {
+ constructor(id, priority, executionTime) {
+ this.id = id;
+ this.priority = priority; 
+ this.executionTime = executionTime;
+ }
+}
+
+class TaskScheduler {
+ constructor() {
+ this.taskQueue = new Heap((a,b) => a.priority - b.priority); 
+ }
+
+ addTask(task) {
+ this.taskQueue.insert(task);
+ }
+
+ scheduleNextTask() {
+ if (this.taskQueue.isEmpty()) {
+ return null; // No tasks to schedule
+ }
+ return this.taskQueue.extract();
+ }
+}
+
+const scheduler = new TaskScheduler();
+scheduler.addTask(new Task(2, 2, 10)); 
+scheduler.addTask(new Task(3, 3, 5)); 
+scheduler.addTask(new Task(4, 4, 8)); 
+scheduler.addTask(new Task(5, 5, 15));
+scheduler.addTask(new Task(1, 1, 20));
+
+console.log(scheduler.taskQueue.toArray());
+
+console.log(scheduler.scheduleNextTask()); // Output: Task 1 (highest priority)
+
+console.log(scheduler.taskQueue.toArray());
+
+// to see the output of this file use the command: node src/11-heap/01-min-heap.js

src/11-heap/02-max-heap.js

@@ -0,0 +1,34 @@
+// src/11-heap/02-max-heap.js
+
+const Heap = require('./heap');
+
+class Patient {
+ constructor(name, priority) {
+ this.name = name;
+ this.priority = priority;
+ }
+}
+
+const PRIORITY = { LOW: 1, MEDIUM: 2, HIGH: 3 };
+
+const erHeap = new Heap((a, b) => b.priority - a.priority);
+
+erHeap.insert(new Patient('Poppy', PRIORITY.LOW));
+erHeap.insert(new Patient('Kieran', PRIORITY.HIGH));
+erHeap.insert(new Patient('Camila', PRIORITY.MEDIUM));
+erHeap.insert(new Patient('Casteel', PRIORITY.LOW));
+erHeap.insert(new Patient('Mike', PRIORITY.HIGH));
+
+console.log('Head', erHeap.toArray());
+
+while (!erHeap.isEmpty()) {
+ const patient = erHeap.extract();
+ console.log('Next patient:', patient.name, patient.priority);
+}
+// Next patient: Kieran 3
+// Next patient: Mike 3
+// Next patient: Camila 2
+// Next patient: Casteel 1
+// Next patient: Poppy 1
+
+// to see the output of this file use the command: node src/11-heap/02-max-heap.js

src/11-heap/03-heap-sort.js

@@ -0,0 +1,29 @@
+// src/11-heap/03-heap-sort.js
+
+const Comparator = require('../10-tree/comparator');
+const Heap = require('./heap');
+const HeapSort = require('./heap-sort');
+
+const heapSort = (array, compareFn = Comparator.defaultCompareFn) => {
+ const heap = new Heap(compareFn);
+ heap.heapify(array);
+
+ const sortedArray = [];
+ while (!heap.isEmpty()){
+ sortedArray.push(heap.extract());
+ }
+
+
+ return heap.toArray();
+};
+
+// using the Heap class and the heapify method
+let unsortedArray = [7, 6, 3, 5, 4, 1, 2];
+console.log(heapSort(unsortedArray)); // [1, 2, 3, 4, 5, 6, 7]
+
+// using the heap sort algorithm
+const unsortedArray = [7, 6, 3, 5, 4, 1, 2];
+HeapSort(unsortedArray); // will modify the array in place
+console.log(unsortedArray); // [1, 2, 3, 4, 5, 6, 7]
+
+// to see the output of this file use the command: node src/11-heap/03-heap-sort.js

src/11-heap/heap-sort.js

@@ -0,0 +1,57 @@
+// src/11-heap/heap-sort.js
+
+const Comparator = require('../10-tree/comparator');
+
+/**
+ * Heapify the array.
+ * @param {*} array to be heapified.
+ * @param {*} heapSize size of the heap.
+ * @param {*} rootIndex index of the root.
+ * @param {*} compareFn compare function.
+*/
+const siftDown = (array, heapSize, rootIndex, compareFn) => {
+ let largest = rootIndex;
+ let left = 2 * rootIndex + 1;
+ let right = 2 * rootIndex + 2;
+
+ if (left < heapSize && compareFn.greaterThan(array[left], array[largest])) {
+ largest = left;
+ }
+
+ if (right < heapSize && compareFn.greaterThan(array[right], array[largest])) {
+ largest = right;
+ }
+
+ if (largest !== rootIndex) {
+ [array[rootIndex], array[largest]] = [array[largest], array[rootIndex]];
+ siftDown(array, heapSize, largest, compareFn);
+ }
+};
+
+/**
+ * Build max heap.
+ * @param {*} array to be heapified.
+ * @param {*} compareFn compare function.
+ */
+const buildMaxHeap = (array, compareFn) => {
+ const heapSize = array.length;
+ for (let i = Math.floor(heapSize / 2) - 1; i >= 0; i--) {
+ siftDown(array, heapSize, i, compareFn);
+ }
+}
+
+/**
+ * Heap sort algorithm.
+ * @param {*} array to be sorted.
+ * @param {*} compareFn compare function.
+ */
+const HeapSort = (array, compareFn = Comparator.defaultCompareFn) => {
+ const defaultCompareFn = new Comparator(compareFn);
+ buildMaxHeap(array, defaultCompareFn);
+ for (let i = array.length - 1; i > 0; i--) {
+ [array[0], array[i]] = [array[i], array[0]];
+ siftDown(array, i, 0, defaultCompareFn);
+ }
+}
+
+module.exports = HeapSort;

src/11-heap/heap.js

@@ -0,0 +1,120 @@
+// src/11-heap/heap.js
+
+const Comparator = require('../10-tree/comparator');
+
+class Heap {
+ #heap = [];
+ #compareFn;
+
+ constructor(compareFn = Comparator.defaultCompareFn) {
+ this.#compareFn = new Comparator(compareFn);
+ }
+
+ getLeftChildIndex(parentIndex) {
+ return 2 * parentIndex + 1;
+ }
+
+ getRightChildIndex(parentIndex) {
+ return 2 * parentIndex + 2;
+ }
+
+ getParentIndex(childIndex) {
+ if (childIndex === 0) { return undefined; }
+ return Math.floor((childIndex - 1) / 2);
+ }
+
+ insert(value) {
+ if (value) {
+ const index = this.#heap.length;
+ this.#heap.push(value);
+ this.#siftUp(index);
+ return true;
+ }
+ return false;
+ }
+
+ #siftUp(index) {
+ const parentIndex = this.getParentIndex(index);
+
+ if (parentIndex !== undefined && parentIndex >= 0 &&
+ this.#compareFn.greaterThan(this.#heap[parentIndex], this.#heap[index])
+ ) {
+ [this.#heap[parentIndex], this.#heap[index]] = [this.#heap[index], this.#heap[parentIndex]];
+ this.#siftUp(parentIndex);
+ }
+ }
+
+ extract() {
+ if (this.#heap.length === 0) {
+ return undefined;
+ }
+
+ if (this.#heap.length === 1) {
+ return this.#heap.shift();
+ }
+
+ const root = this.#heap[0];
+ this.#heap[0] = this.#heap.pop();
+ this.#siftDown(0);
+ return root;
+ }
+
+ #siftDown(index) {
+ const leftIndex = this.getLeftChildIndex(index);
+ const rightIndex = this.getRightChildIndex(index);
+ let smallerIndex = index;
+
+ if (leftIndex < this.#heap.length &&
+ this.#compareFn.lessThan(this.#heap[leftIndex], this.#heap[smallerIndex])
+ ) {
+ smallerIndex = leftIndex;
+ }
+
+ if (rightIndex < this.#heap.length &&
+ this.#compareFn.lessThan(this.#heap[rightIndex], this.#heap[smallerIndex])
+ ) {
+ smallerIndex = rightIndex;
+ }
+
+ if (smallerIndex !== index) {
+ [this.#heap[index], this.#heap[smallerIndex]] = [this.#heap[smallerIndex], this.#heap[index]];
+ this.#siftDown(smallerIndex);
+ }
+ }
+
+ heapify(array) {
+ this.#heap = array;
+ const lastParentIndex = this.getParentIndex(this.#heap.length - 1);
+ if (lastParentIndex !== undefined) {
+ for (let i = lastParentIndex; i >= 0; i--) {
+ this.#siftDown(i);
+ }
+ }
+ }
+
+ peek() {
+ return this.#heap.length === 0 ? undefined : this.#heap[0];
+ }
+
+ get size() {
+ return this.#heap.length;
+ }
+
+ isEmpty() {
+ return this.#heap.length === 0;
+ }
+
+ toArray() {
+ return this.#heap.slice();
+ }
+
+ clear() {
+ this.#heap = [];
+ }
+
+ toString() {
+ return this.#heap.toString();
+ }
+} 
+
+module.exports = Heap;

src/11-heap/leetcode/minimum-number-game.ts

@@ -0,0 +1,58 @@
+// https://leetcode.com/problems/minimum-number-game/description/
+// 2974. Minimum Number Game
+
+function siftDown (array: number[], heapSize: number, rootIndex: number) {
+ let largest = rootIndex;
+ let left = 2 * rootIndex + 1;
+ let right = 2 * rootIndex + 2;
+
+ if (left < heapSize && array[left] > array[largest]) {
+ largest = left;
+ }
+
+ if (right < heapSize && array[right] > array[largest]) {
+ largest = right;
+ }
+
+ if (largest !== rootIndex) {
+ [array[rootIndex], array[largest]] = [array[largest], array[rootIndex]];
+ siftDown(array, heapSize, largest);
+ }
+};
+
+
+function buildMaxHeap (array: number[]) {
+ const heapSize = array.length;
+ for (let i = Math.floor(heapSize / 2) - 1; i >= 0; i--) {
+ siftDown(array, heapSize, i);
+ }
+}
+
+function heapSort(array: number[]) {
+ buildMaxHeap(array);
+ for (let i = array.length - 1; i > 0; i--) {
+ [array[0], array[i]] = [array[i], array[0]];
+ siftDown(array, i, 0);
+ }
+}
+
+function numberGame(nums: number[]): number[] {
+ // nums.sort((a, b) => a - b);
+ heapSort(nums);
+ const arr: number[] = [];
+ while (nums.length > 0) {
+ const alice = nums.splice(0, 1)[0];
+ const bob = nums.splice(0, 1)[0];
+ arr.push(bob);
+ arr.push(alice);
+ }
+ return arr;
+};
+
+console.log(numberGame([5,4,2,3])); // [ 3, 2, 5, 4 ]
+console.log(numberGame([2,5])); // [ 5, 2 ]
+
+// Time complexity: O(nlogn)
+// Space complexity: O(n)
+
+// to see the output of this file use the command: npx ts-node src/11-heap/leetcode/minimum-number-game.ts