chapter 10: [Heap]

Author: loiane

Diff for: examples/PacktDataStructuresAlgorithms.min.js

@@ -21,12 +21,10 @@ export default class BinarySearchTree {
       } else {
         this.insertNode(node.left, key);
       }
+    } else if (node.right == null) {
+      node.right = new Node(key);
     } else {
-      if (node.right == null) {
-        node.right = new Node(key);
-      } else {
-        this.insertNode(node.right, key);
-      }
+      this.insertNode(node.right, key);
     }
   }
   getRoot() {
@@ -43,9 +41,8 @@ export default class BinarySearchTree {
       return this.searchNode(node.left, key);
     } else if (this.compareFn(key, node.key) === Compare.BIGGER_THAN) {
       return this.searchNode(node.right, key);
-    } else {
-      return true;
     }
+    return true;
   }
   inOrderTraverse(callback) {
     this.inOrderTraverseNode(this.root, callback);
@@ -110,30 +107,29 @@ export default class BinarySearchTree {
     } else if (this.compareFn(key, node.key) === Compare.BIGGER_THAN) {
       node.right = this.removeNode(node.right, key);
       return node;
-    } else {
-      // key is equal to node.item
-      // handle 3 special conditions
-      // 1 - a leaf node
-      // 2 - a node with only 1 child
-      // 3 - a node with 2 children
-      // case 1
-      if (node.left == null && node.right == null) {
-        node = null;
-        return node;
-      }
-      // case 2
-      if (node.left == null) {
-        node = node.right;
-        return node;
-      } else if (node.right == null) {
-        node = node.left;
-        return node;
-      }
-      // case 3
-      const aux = this.minNode(node.right);
-      node.key = aux.key;
-      node.right = this.removeNode(node.right, aux.key);
+    }
+    // key is equal to node.item
+    // handle 3 special conditions
+    // 1 - a leaf node
+    // 2 - a node with only 1 child
+    // 3 - a node with 2 children
+    // case 1
+    if (node.left == null && node.right == null) {
+      node = null;
+      return node;
+    }
+    // case 2
+    if (node.left == null) {
+      node = node.right;
+      return node;
+    } else if (node.right == null) {
+      node = node.left;
       return node;
     }
+    // case 3
+    const aux = this.minNode(node.right);
+    node.key = aux.key;
+    node.right = this.removeNode(node.right, aux.key);
+    return node;
   }
 }

Diff for: src/js/data-structures/binary-search-tree.js

@@ -6,10 +6,10 @@ export class MinHeap {
     this.heap = [];
   }
   getLeftIndex(index) {
-    return 2 * index + 1;
+    return (2 * index) + 1;
   }
   getRightIndex(index) {
-    return 2 * index + 2;
+    return (2 * index) + 2;
   }
   getParentIndex(index) {
     if (index === 0) {

Diff for: src/js/data-structures/heap.js

@@ -47,6 +47,6 @@ export { default as BinarySearchTree } from './data-structures/binary-search-tre
 export { default as AVLTree } from './data-structures/avl-tree';
 
 // chapter 10
-export { MinHeap as MinHeap } from './data-structures/heap';
-export { MaxHeap as MaxHeap } from './data-structures/heap';
-export { default as heapSort } from './data-structures/sorting/heap-sort';
+export { MinHeap } from './data-structures/heap';
+export { MaxHeap } from './data-structures/heap';
+export { default as heapSort } from './sorting/heap-sort';

Diff for: src/js/index.js

@@ -2,8 +2,8 @@ import { defaultCompare, swap } from '../util';
 
 function heapify(array, index, heapSize, compareFn) {
   let largest = index;
-  const left = 2 * index + 1;
-  const right = 2 * index + 2;
+  const left = (2 * index) + 1;
+  const right = (2 * index) + 2;
   if (left < heapSize && compareFn(array[left], array[index]) > 0) {
     largest = left;
   }

Diff for: src/js/sorting/heap-sort.js

@@ -22,12 +22,10 @@ export default class BinarySearchTree<T> {
       } else {
         this.insertNode(node.left, key);
       }
+    } else if (node.right == null) {
+      node.right = new Node(key);
     } else {
-      if (node.right == null) {
-        node.right = new Node(key);
-      } else {
-        this.insertNode(node.right, key);
-      }
+      this.insertNode(node.right, key);
     }
   }
 
@@ -48,10 +46,9 @@ export default class BinarySearchTree<T> {
       return this.searchNode(node.left, key);
     } else if (this.compareFn(key, node.key) === Compare.BIGGER_THAN) {
       return this.searchNode(node.right, key);
-    } else {
-      // key is equal to node.item
-      return true;
     }
+    // key is equal to node.item
+    return true;
   }
 
   inOrderTraverse(callback: Function) {

Diff for: src/ts/data-structures/binary-search-tree.ts

@@ -0,0 +1,16 @@
+import Dictionary from './dictionary';
+
+export default class Graph<T> {
+  private vertices: T[] = [];
+  private adjList: Dictionary<T, T[]> = new Dictionary();
+
+  addVertex(v: T) {
+    this.vertices.push(v);
+    this.adjList.set(v, []); // initialize adjacency list with array as well;
+  }
+
+  addEdge(v: T, w: T) {
+    this.adjList.get(v).push(w);
+    // adjList.get(w).push(v); //commented to run the improved DFS with topological sorting
+  }
+}

Diff for: src/ts/data-structures/graph.ts

@@ -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) {

Diff for: src/ts/data-structures/heap.ts

@@ -2,8 +2,8 @@ import { defaultCompare, ICompareFunction, swap } from '../util';
 
 function heapify(array: any[], index: number, heapSize: number, compareFn: ICompareFunction<any>) {
   let largest = index;
-  const left = 2 * index + 1;
-  const right = 2 * index + 2;
+  const left = (2 * index) + 1;
+  const right = (2 * index) + 2;
 
   if (left < heapSize && compareFn(array[left], array[index]) > 0) {
     largest = left;