Merge pull request knaxus#56 from knaxus/problems

delete() & enhancements in BST

Author: ashokdey

src/_DataStructures_/Trees/BST/index.js

@@ -82,29 +82,129 @@ class BinarySearchTree {
     }
     return false;
   }
+
+  delete(root, value) {
+    if (root === null) {
+      return root;
+    }
+
+    if (value > root.value) {
+      // eslint-disable-next-line no-param-reassign
+      root.rightChild = this.delete(root.rightChild, value);
+    } else if (value < root.value) {
+      // eslint-disable-next-line no-param-reassign
+      root.leftChild = this.delete(root.leftChild, value);
+    } else {
+      // found the node
+      if (root.leftChild === null) {
+        // there is a right sub-tree
+        return root.rightChild;
+      }
+      if (root.rightChild === null) {
+        // there is a left sub-tree
+        return root.leftChild;
+      }
+      /**
+       * the root contain 2 childs, we got 2 options:
+       * 1. We can either find the Node with minimum value at from the right sub-tree
+       * 2. Or, we can find the Node with maximum value from the left sub-tree
+       *
+       * I'm picking up 1 here
+       */
+      const minRightNode = this.findMinNode(root.rightChild);
+      // eslint-disable-next-line no-param-reassign
+      root.value = minRightNode.value;
+      // eslint-disable-next-line no-param-reassign
+      root.rightChild = this.delete(root.rightChild, minRightNode.value);
+      return root;
+    }
+    return root;
+  }
+
+  findMinNode(root) {
+    /** The minnimum values is the let most leaf node in BST */
+    if (root.leftChild === null) return root;
+    return this.findMinNode(root.leftChild);
+  }
+
+  findMaxNode(root) {
+    if (root.rightChild === null) return root;
+    return this.findMaxNode(root.rightChild);
+  }
+
+  isEmpty() {
+    return this.root === null;
+  }
+
+  /** Layered methods to simplify the BST API  */
+
+  add(value) {
+    return this.insert(this.root, value);
+  }
+
+  traversePreorder() {
+    return this.preorder(this.root);
+  }
+
+  traversePostorder() {
+    return this.postorder(this.root);
+  }
+
+  traverseInorder() {
+    return this.inorder(this.root);
+  }
+
+  searchFor(value) {
+    return this.search(this.root, value);
+  }
+
+  getMinimum() {
+    const minNode = this.findMinNode(this.root);
+    return minNode.value;
+  }
+
+  getMaximum() {
+    const maxNode = this.findMaxNode(this.root);
+    return maxNode.value;
+  }
+
+  remove(value) {
+    return this.delete(this.root, value);
+  }
 }
 
 // const bst = new BinarySearchTree(6);
 // console.log(bst.root);
-// bst.insert(bst.root, 4);
-// bst.insert(bst.root, 9);
-// bst.insert(bst.root, 2);
-// bst.insert(bst.root, 5);
-// bst.insert(bst.root, 8);
-// bst.insert(bst.root, 12);
+// bst.add(4);
+// bst.add(9);
+// bst.add(2);
+// bst.add(5);
+// bst.add(8);
+// bst.add(12);
 
 // console.log(bst.root);
 
-// const preorder = bst.preorder(bst.root);
+// const preorder = bst.traversePreorder();
 // console.log('Preorder Traversal - ', preorder);
 
-// const inorder = bst.inorder(bst.root);
+// const inorder = bst.traverseInorder();
 // console.log('Inorder Traversal - ', inorder);
 
-// const postorder = bst.postorder(bst.root);
+// const postorder = bst.traversePostorder();
 // console.log('Postorder Traversal - ', postorder);
 
 // const search = 18;
-// console.log(`Search for ${search}`, bst.search(bst.root, search));
+// console.log(`Search for ${search}`, bst.searchFor(search));
+
+// const minNode = bst.getMinimum();
+// console.log('Minimum value =>', minNode);
+
+// const maxNode = bst.getMaximum();
+// console.log('Maximum value =>', maxNode);
+
+// bst.remove(4);
+// console.log(bst.traversePreorder());
+
+// console.log(bst.root);
 
 module.exports = BinarySearchTree;