Binary Tree to BST

-  Return null value
- Using Node Class already existed
- Mentioned Runtime complexity of function
- Return BST root node
- Used BinaryTree implementation to create the tree.

Author: k88manish

src/_DataStructures_/Trees/BinaryTree/index.js

@@ -3,14 +3,14 @@ const Node = require('./Node');
 class BinaryTree {
   constructor(arr) {
     if (!Array.isArray(arr) || !arr.length) {
-      throw new Error('Invalid argument to create a Binary Tre');
+      throw new Error('Invalid argument to create a Binary Tree');
     }
     this.root = this.createBinaryTree((this.root = null), arr, 0);
   }
 
   // eslint-disable-next-line class-methods-use-this
   createBinaryTree(root, arr, i) {
-    if (i < arr.length) {
+    if (i < arr.length && arr[i]) {
       // eslint-disable-next-line no-param-reassign
       root = new Node(arr[i]);
       // eslint-disable-next-line no-param-reassign

src/_Problems_/binary-tree-to-binary-search-tree/Node.js

@@ -1,19 +1,15 @@
 const { binaryTreeToBST, storeInorder } = require('.');
-const Node = require('./Node');
+const BinaryTree = require('../../_DataStructures_/Trees/BinaryTree');
 
 describe('Binary tree to binary search tree', () => {
   let tree;
 
   describe('Create Binary Tree', () => {
-    tree = new Node(10);
-    tree.leftChild = new Node(30);
-    tree.leftChild.leftChild = new Node(20);
-    tree.rightChild = new Node(15);
-    tree.rightChild.rightChild = new Node(5);
+    tree = new BinaryTree([10, 30, 15, 20, null, null, 5]);
   });
 
   it('Should converted binary tree to binary search tree', () => {
-    binaryTreeToBST(tree);
-    expect(storeInorder(tree)).toEqual([5, 10, 15, 20, 30]);
+    const bTree = binaryTreeToBST(tree);
+    expect(storeInorder(bTree)).toEqual([5, 10, 15, 20, 30]);
   });
 });

src/_Problems_/binary-tree-to-binary-search-tree/binary-tree-to-binary-search-tree.test.js

@@ -16,6 +16,7 @@ Output:
       2   7
  */
 
+const Node = require('../../_DataStructures_/Trees/BinaryTree/Node');
 // Helper function to store inorder traversal of a binary tree
 function storeInorder(root) {
   /** left - root - right */
@@ -36,27 +37,39 @@ function storeInorder(root) {
 }
 
 // Helper function to copy elements from sorted array to make BST while keeping same structure
+// Runtime complexity iof this function is O(n) where n is number of nodes, as we are each node of tree one time.
 function arrayToBST(arr, root) {
   const node = root;
   // Base case
-  if (!node) return;
+  if (!node) return null;
 
+  const bstNode = new Node();
   // First update the left subtree
-  arrayToBST(arr, node.leftChild);
+  const leftChild = arrayToBST(arr, node.leftChild);
+  if (leftChild) {
+    bstNode.leftChild = leftChild;
+  }
 
   // update the root's data and remove it from sorted array
-  node.value = arr.shift();
+  // eslint-disable-next-line no-param-reassign
+  bstNode.value = arr.shift();
 
   // Finally update the right subtree
-  arrayToBST(arr, node.rightChild);
+  const rightChild = arrayToBST(arr, node.rightChild);
+  if (rightChild) {
+    bstNode.rightChild = rightChild;
+  }
+
+  return bstNode;
 }
 
-function binaryTreeToBST(root) {
+function binaryTreeToBST(bTree) {
   // Tree is empty
-  if (!root) return;
-  const arr = storeInorder(root);
+  if (!bTree.root) return null;
+  const arr = bTree.preOrder();
   arr.sort((a, b) => a - b);
-  arrayToBST(arr, root);
+  const bst = arrayToBST(arr, bTree.root);
+  return bst;
 }
 
 module.exports = {