[Heap]

Author: loiane

examples/PacktDataStructuresAlgorithms.min.js

@@ -1,25 +1,27 @@
 const { MinHeap } = PacktDataStructuresAlgorithms;
 
-const heap = new MinHeap();
+let heap = new MinHeap();
 
 heap.insert(2);
 heap.insert(3);
 heap.insert(4);
 heap.insert(5);
 
-heap.insert(1);
+heap.insert(2);
 
 console.log(heap.getAsArray());
 
 console.log('Heap size: ', heap.size()); // 5
 console.log('Heap is empty: ', heap.isEmpty()); // false
 console.log('Heap min value: ', heap.findMinimum()); // 1
 
-heap.insert(6);
-heap.insert(7);
+heap = new MinHeap();
+for (let i = 1; i < 10; i++) {
+  heap.insert(i);
+}
 
 console.log(heap.getAsArray());
 
 console.log('Extract minimum: ', heap.extract());
-console.log(heap.getAsArray());
+console.log(heap.getAsArray()); // [2, 4, 3, 8, 5, 6, 7, 9]
 

examples/PacktDataStructuresAlgorithms.min.js.map

@@ -78,7 +78,8 @@ export class MinHeap {
     if (this.size() === 1) {
       return this.heap.shift();
     }
-    const removedValue = this.heap.shift();
+    const removedValue = this.heap[0];
+    this.heap[0] = this.heap.pop();
     this.siftDown(0);
     return removedValue;
   }

examples/chapter10/01-UsingMinHeap.js

@@ -6,11 +6,11 @@ export class MinHeap<T> {
   constructor(protected compareFn: ICompareFunction<T> = defaultCompare) {}
 
   private getLeftIndex(index: number) {
-    return (2 * index) + 1;
+    return 2 * index + 1;
   }
 
   private getRightIndex(index: number) {
-    return (2 * index) + 2;
+    return 2 * index + 2;
   }
 
   private getParentIndex(index: number) {
@@ -71,7 +71,10 @@ export class MinHeap<T> {
 
   private siftUp(index: number): void {
     let parent = this.getParentIndex(index);
-    while (index > 0 && this.compareFn(this.heap[parent], this.heap[index]) === Compare.BIGGER_THAN) {
+    while (
+      index > 0 &&
+      this.compareFn(this.heap[parent], this.heap[index]) === Compare.BIGGER_THAN
+    ) {
       swap(this.heap, parent, index);
       index = parent;
       parent = this.getParentIndex(index);
@@ -85,7 +88,8 @@ export class MinHeap<T> {
     if (this.size() === 1) {
       return this.heap.shift();
     }
-    const removedValue = this.heap.shift();
+    const removedValue = this.heap[0];
+    this.heap[0] = this.heap.pop();
     this.siftDown(0);
     return removedValue;
   }

src/js/data-structures/heap.js

@@ -11,56 +11,67 @@ describe('Heap', () => {
     heap = new MinHeap<number>();
   });
 
-  it('starts empty', () => {
-
+  it('starts empty MinHeap', () => {
+    expect(heap.size()).to.equal(0);
+    expect(heap.isEmpty()).to.equal(true);
   });
 
-  it('inserts elements in the Heap', () => {
-
-    let min = 2;
-
-    heap.insert(2);
-    expect(heap.findMinimum()).to.equal(min);
-    heap.insert(3);
-    expect(heap.findMinimum()).to.equal(min);
-    heap.insert(4);
-    expect(heap.findMinimum()).to.equal(min);
-    heap.insert(5);
-    expect(heap.findMinimum()).to.equal(min);
-
-    heap.insert(1);
-    min = 1;
-    expect(heap.findMinimum()).to.equal(min);
-
-    heap.insert(6);
-    heap.insert(9);
-    heap.insert(10);
-    heap.insert(14);
-
-    heap.extract();
-    heap.extract();
-    heap.extract();
-    heap.extract();
-
-    heap.isEmpty();
+  it('inserts values in the MinHeap', () => {
+    const resultArray = [];
+    for (let i = 1; i < 10; i++) {
+      resultArray.push(i);
+      heap.insert(i);
+      expect(heap.getAsArray()).to.deep.equal(resultArray);
+    }
+  });
 
-    const maxHeap = new MaxHeap<number>();
-    maxHeap.insert(3);
-    maxHeap.insert(2);
-    maxHeap.insert(1);
-    maxHeap.insert(4);
+  it('finds the min value from the MinHeap', () => {
+    const resultArray = [];
+    for (let i = 10; i >= 1; i--) {
+      resultArray.push(i);
+      heap.insert(i);
+      expect(heap.findMinimum()).to.equal(i);
+    }
+  });
 
-    maxHeap.extract();
-    maxHeap.extract();
-    maxHeap.extract();
-    maxHeap.extract();
+  it('performs heapify in the MinHeap', () => {
+    const resultArray = [];
+    for (let i = 10; i >= 1; i--) {
+      resultArray.push(i);
+    }
+    expect(heap.heapify(resultArray)).to.deep.equal(resultArray);
+  });
 
-    maxHeap.isEmpty();
+  it('extracts the min value from the MinHeap', () => {
+    let resultArray = [];
+    for (let i = 1; i < 10; i++) {
+      resultArray.push(i);
+      heap.insert(i);
+      expect(heap.getAsArray()).to.deep.equal(resultArray);
+    }
+
+    resultArray = [
+      [],
+      [2, 4, 3, 8, 5, 6, 7, 9],
+      [3, 4, 6, 8, 5, 9, 7],
+      [4, 5, 6, 8, 7, 9],
+      [5, 7 , 6, 8, 9],
+      [6, 7, 9, 8],
+      [7, 8, 9],
+      [8, 9],
+      [9],
+      []
+    ];
+
+    for (let i = 1; i < 10; i++) {
+      expect(heap.extract()).to.equal(i);
+      expect(heap.getAsArray()).to.deep.equal(resultArray[i]);
+    }
   });
 
   it('Heap Sort', () => {
     const array = [3, 2, 5, 6, 1, 7, 8, 9];
 
-    heapSort(array);
+    expect(heapSort(array)).to.deep.equal([1, 2, 3, 5, 6, 7, 8, 9]);
   });
 });