feat(heap): add error handling for heaps

BREAKING CHANGE: size is now an attribute rather than a method. Similar to the built-in Map.size and Set.size

Author: amejiarosario

src/data-structures/heaps/heap.js

@@ -8,7 +8,11 @@
 class Heap {
   constructor(comparator = (a, b) => a - b) {
     this.array = [];
-    this.comparator = (i1, i2) => comparator(this.array[i1], this.array[i2]);
+    this.comparator = (i1, i2) => {
+      const value = comparator(this.array[i1], this.array[i2]);
+      if (Number.isNaN(value)) { throw new Error(`Comparator should evaluate to a number. Got ${value} when comparing ${this.array[i1]} with ${this.array[i2]}`); }
+      return value;
+    };
   }
 
   /**
@@ -34,8 +38,8 @@ class Heap {
    * @runtime O(log n)
    */
   remove(index = 0) {
-    if (!this.size()) return null;
-    this.swap(index, this.size() - 1); // swap with last
+    if (!this.size) return null;
+    this.swap(index, this.size - 1); // swap with last
     const value = this.array.pop(); // remove element
     this.bubbleDown(index);
     return value;
@@ -45,7 +49,7 @@ class Heap {
    * Returns the number of elements in this collection.
    * @runtime O(1)
    */
-  size() {
+  get size() {
     return this.array.length;
   }
 
@@ -54,7 +58,7 @@ class Heap {
    * @runtime O(log n)
    */
   bubbleUp() {
-    let index = this.size() - 1;
+    let index = this.size - 1;
     const parent = (i) => Math.ceil(i / 2 - 1);
     while (parent(index) >= 0 && this.comparator(parent(index), index) > 0) {
       this.swap(parent(index), index);
@@ -70,18 +74,18 @@ class Heap {
     let curr = index;
     const left = (i) => 2 * i + 1;
     const right = (i) => 2 * i + 2;
-    const getTopChild = (i) => (right(i) < this.size()
+    const getTopChild = (i) => (right(i) < this.size
       && this.comparator(left(i), right(i)) > 0 ? right(i) : left(i));
 
-    while (left(curr) < this.size() && this.comparator(curr, getTopChild(curr)) > 0) {
+    while (left(curr) < this.size && this.comparator(curr, getTopChild(curr)) > 0) {
       const next = getTopChild(curr);
       this.swap(curr, next);
       curr = next;
     }
   }
 
   /**
-   * "Private": Swap elements on the heap
+   * Swap elements on the heap
    * @runtime O(1)
    * @param {number} i1 index 1
    * @param {number} i2 index 2

src/data-structures/heaps/heap.spec.js

@@ -3,12 +3,16 @@ const PriorityQueue = require('./priority-queue');
 const MaxHeap = require('./max-heap');
 const MinHeap = require('./min-heap');
 
-[[Heap], [PriorityQueue], [MinHeap]].forEach(([DS, arg]) => {
-  describe('Min-Heap (Priority Queue)', () => {
+[
+  [Heap],
+  [PriorityQueue, [], (a, b) => a - b],
+  [MinHeap],
+].forEach(([DS, ...arg]) => {
+  describe('Min-Heap and Priority Queue', () => {
     let heap;
 
     beforeEach(() => {
-      heap = new DS(arg);
+      heap = new DS(...arg);
     });
 
     describe('#contructor', () => {
@@ -21,7 +25,7 @@ const MinHeap = require('./min-heap');
       it('should add an element', () => {
         expect(heap.add(1)).toBe(undefined);
         expect(heap.array).toEqual([1]);
-        expect(heap.size()).toBe(1);
+        expect(heap.size).toBe(1);
       });
 
       it('should keep things in order', () => {
@@ -31,7 +35,7 @@ const MinHeap = require('./min-heap');
         expect(heap.array[0]).toEqual(2);
         heap.add(1);
         expect(heap.array[0]).toEqual(1);
-        expect(heap.size()).toEqual(3);
+        expect(heap.size).toEqual(3);
       });
     });
 
@@ -40,7 +44,7 @@ const MinHeap = require('./min-heap');
         heap.add(1);
         heap.add(0);
         expect(heap.remove()).toBe(0);
-        expect(heap.size()).toBe(1);
+        expect(heap.size).toBe(1);
         expect(heap.array).toEqual([1]);
       });
 
@@ -70,19 +74,23 @@ const MinHeap = require('./min-heap');
           expect(heap.remove()).toEqual(1);
           expect(heap.remove()).toEqual(2);
           expect(heap.remove()).toEqual(3);
-          expect(heap.size()).toBe(0);
+          expect(heap.size).toBe(0);
         });
       });
     });
   });
 });
 
-[[Heap, (a, b) => b - a], [PriorityQueue, (a, b) => b - a], [MaxHeap]].forEach(([DS, arg]) => {
+[
+  [Heap, (a, b) => b - a],
+  [PriorityQueue, [], (a, b) => b - a],
+  [MaxHeap],
+].forEach(([DS, ...arg]) => {
   describe('Max-Heap (Priority Queue)', () => {
     let heap;
 
     beforeEach(() => {
-      heap = new DS(arg);
+      heap = new DS(...arg);
     });
 
     describe('#contructor', () => {
@@ -95,7 +103,7 @@ const MinHeap = require('./min-heap');
       it('should add an element', () => {
         expect(heap.add(1)).toBe(undefined);
         expect(heap.array).toEqual([1]);
-        expect(heap.size()).toBe(1);
+        expect(heap.size).toBe(1);
       });
 
       it('should keep things in order', () => {
@@ -105,7 +113,7 @@ const MinHeap = require('./min-heap');
         expect(heap.array[0]).toEqual(2);
         heap.add(3);
         expect(heap.array[0]).toEqual(3);
-        expect(heap.size()).toEqual(3);
+        expect(heap.size).toEqual(3);
       });
     });
 
@@ -114,7 +122,7 @@ const MinHeap = require('./min-heap');
         heap.add(1);
         heap.add(0);
         expect(heap.remove()).toBe(1);
-        expect(heap.size()).toBe(1);
+        expect(heap.size).toBe(1);
         expect(heap.array).toEqual([0]);
       });
 
@@ -156,7 +164,7 @@ const MinHeap = require('./min-heap');
           expect(heap.remove()).toEqual(2);
           expect(heap.remove()).toEqual(1);
           expect(heap.remove()).toEqual(0);
-          expect(heap.size()).toBe(0);
+          expect(heap.size).toBe(0);
         });
       });
     });

src/data-structures/heaps/median-heap.js

@@ -30,9 +30,9 @@ class MedianHeap {
     }
 
     // rebalance if the sizes of the heaps differ by more than one element
-    if (Math.abs(this.min.size() - this.max.size()) > 1) {
+    if (Math.abs(this.min.size - this.max.size) > 1) {
       // extract the min/max from the heap with more elements and insert it into the other heap.
-      if (this.min.size() > this.max.size()) {
+      if (this.min.size > this.max.size) {
         this.max.add(this.min.remove());
       } else {
         this.min.add(this.max.remove());
@@ -47,12 +47,12 @@ class MedianHeap {
   findMedian() {
     let median;
 
-    if (this.max.size() === this.min.size()) {
+    if (this.max.size === this.min.size) {
       // When both heaps contain the same number of elements,
       // the total number of elements is even.
       // The median is the mean of the two middle elements.
       median = (this.max.peek() + this.min.peek()) / 2;
-    } else if (this.max.size() > this.min.size()) {
+    } else if (this.max.size > this.min.size) {
       // when the max-heap contains one more element than the min-heap,
       //  the median is in the top of the max-heap.
       median = this.max.peek();
@@ -67,8 +67,8 @@ class MedianHeap {
   /**
    * Return size of the heap.
    */
-  size() {
-    return this.min.size() + this.max.size();
+  get size() {
+    return this.min.size + this.max.size;
   }
 }
 

src/data-structures/heaps/median-heap.spec.js

@@ -10,13 +10,13 @@ describe('Median Heap', () => {
   describe('#add', () => {
     it('should work', () => {
       expect(medianHeap.add(1)).toEqual(undefined);
-      expect(medianHeap.size()).toEqual(1);
+      expect(medianHeap.size).toEqual(1);
     });
 
     it('should work', () => {
       expect(medianHeap.add(1)).toEqual(undefined);
       expect(medianHeap.add(1)).toEqual(undefined);
-      expect(medianHeap.size()).toEqual(2);
+      expect(medianHeap.size).toEqual(2);
     });
   });