Completed BST insert method (#7 IP)

Author: CoffeelessProgrammer

Data-Structures/Arrays/Implementation.ts

@@ -1,5 +1,3 @@
-// RUN:   deno run Data-Structures/Arrays/Implementation.ts
-
 type NumIndexedObject = { [index: number]: any };
 
 export class MyArray<T> {
@@ -119,6 +117,8 @@ if (import.meta.main) {
 
   sokka.insertItemAtIndex(2, 'k');  // O(n)
   console.log(sokka);
+
+  // RUN:   deno run Data-Structures/Arrays/Implementation.ts
 }
 
 // --------------------------- Terminal Output: ---------------------------

Data-Structures/Hash-Tables/Implementation.ts

@@ -1,5 +1,3 @@
-// RUN: deno run Data-Structures/Hash-Tables/Implementation.ts
-
 export class HashTable {
   private size: number;
   private data: Array<Array<any>>;
@@ -103,4 +101,6 @@ if (import.meta.main) {
 
   console.log(hashTable.keys());
   console.log(hashTable.values());
+
+  // RUN: deno run Data-Structures/Hash-Tables/Implementation.ts
 }

Data-Structures/Trees/BinarySearchTree.ts

@@ -0,0 +1,94 @@
+import BNode from './BinaryTreeNode.ts';
+
+
+export default class BinarySearchTree {
+  private root: BNode | null;
+
+  constructor() {
+    this.root = null;
+  }
+
+  public getRoot(): BNode | null {
+    return this.root;
+  }
+
+  public insert(value: number) {
+    // TODO: Insert value into BST
+
+    // If empty tree, create root
+    if(this.root === null) {
+      this.root = new BNode(value);
+      return this.root;
+    }
+
+    // Otherwise, traverse tree to find correct insert location
+    let currentNode: BNode = this.root;
+
+    while(true) {
+      // Value is smaller than current node
+      if (value < currentNode.getValue()) {
+        if(!currentNode.getLeft()) {                // If no left node on currentNode
+          currentNode.setLeft(new BNode(value));    // Create left node with value
+          return this;
+        } else {
+          currentNode = currentNode.getLeft();      // Otherwise, go into existing left node
+          continue;                                 // Small optimization
+        }
+      }
+
+      // Value is greater than or equal to current node
+      if (value >= currentNode.getValue()) {
+        if(!currentNode.getRight()) {               // If no right node on currentNode
+          currentNode.setRight(new BNode(value));   // Create right node with value  
+          return this;
+        } else {
+          currentNode = currentNode.getRight();     // Otherwise, go into the existing right node
+          continue;                                 // Small optimization
+        }
+      }
+    }
+  }
+
+  public lookup(value: number) {
+    // TODO: Find value in BST
+    console.log("Lookup not implemented");
+  }
+
+  public remove(value: number) {
+    // TODO: Remove from node from BST
+    console.log("Remove not implemented");
+  }
+}
+
+function traverseFrom(node: BNode | null) {
+  if(node === null) return;
+
+  const tree = Object.create({});
+  tree.value = node.getValue();
+  tree.left = node.getLeft() === null ? null : traverseFrom(node.getLeft());
+  tree.right = node.getRight() === null ? null : traverseFrom(node.getRight());
+  return tree;
+}
+
+//---------------------------------------------------------------------
+// ----------                 MAIN PROGRAM                   ----------
+//---------------------------------------------------------------------
+if (import.meta.main) {
+
+  const tree = new BinarySearchTree();
+
+  //        9
+  //    4       20
+  //  1   6   15   170
+
+  tree.insert(9);
+  tree.insert(4);
+  tree.insert(6);
+  tree.insert(20);
+  tree.insert(170);
+  tree.insert(15);
+  tree.insert(1);
+  console.log(JSON.stringify(traverseFrom(tree.getRoot())));
+
+  // RUN: deno run Data-Structures/Trees/BinarySearchTree.ts
+}

Data-Structures/Trees/BinaryTreeNode.ts

@@ -0,0 +1,35 @@
+export default class BinaryTreeNode {
+  private value: number;
+  private left: BinaryTreeNode | null;
+  private right: BinaryTreeNode | null;
+
+  constructor(value: number) {
+    this.left = null;
+    this.right = null;
+    this.value = value;
+  }
+
+  public setValue(value: number) {
+    this.value = value;
+  }
+
+  public setRight(binaryTreeNode: BinaryTreeNode) {
+    this.right = binaryTreeNode;
+  }
+
+  public setLeft(binaryTreeNode: BinaryTreeNode) {
+    this.left = binaryTreeNode;
+  }
+
+  public getValue(): number {
+    return this.value;
+  }
+
+  public getRight(): BinaryTreeNode | any {
+    return this.right;
+  }
+
+  public getLeft(): BinaryTreeNode | any {
+    return this.left;
+  }
+}