trees complete with insert, search and delete

Author: solotahoe

Diff for: Dsa.js

@@ -1,8 +1,5 @@
 // Problem Statement:
-// Given a binary tree, find the 
-//maximum depth (height) of the tree. 
-//The maximum depth of a binary tree is the
-// length of the longest path from the root node to any leaf node
+// Given a binary tree, find the maximum depth (height) of the tree. The maximum depth of a binary tree is the length of the longest path from the root node to any leaf node
 class TreeNode {
     constructor(value) {
       this.value = value;
@@ -12,7 +9,7 @@ class TreeNode {
   }
 
 //javascript implementation
-  // Helper function to create a binary tree for demonstration purposes   
+  // Helper function to create a binary tree for demonstration purposes
 function createBinaryTree() {
     const root = new TreeNode(1);
     root.left = new TreeNode(2);
@@ -32,16 +29,16 @@ function maxDepth(root) {
       return 0;
     } else {
       const leftDepth = maxDepth(root.left);
-      // console.log(leftDepth)
-      console.log("leftpath:", leftDepth); 
+      console.log("left depht is",leftDepth)
       const rightDepth = maxDepth(root.right);
-      // console.log(rightDepth)
+      console.log("right depht is",rightDepth)
       return 1 + Math.max(leftDepth, rightDepth);
     }
   }
 
   // Example usage:
   const root = createBinaryTree();
+   console.log("root is",root)
   const depth = maxDepth(root);
   console.log("Maximum Depth of Binary Tree:", depth); // Output: Maximum Depth of Binary Tree: 3
 

Diff for: README.md

@@ -1,7 +1,7 @@
  # WHAT ARE TREESS
   A tree is a **hierarchical data structure** consisting of nodes connected by edges
 
- - Each node in a tree has a parent node (except for the root node) and zero or more child nodes. The topmost node in a tree is called the "root," and nodes with no children are called "leaves."
+ - Each node in a tree has a parent node (except for the root node) and zero or more child nodes. The topmost node in a tree is called the "root," and nodes with no children are called "leafs."
 
   [image visualization of a tree structure](https://media.geeksforgeeks.org/wp-content/uploads/20221124153129/Treedatastructure.png)
 

Diff for: binary.js

@@ -0,0 +1,81 @@
+// Define a Node class to represent each node in the binary search tree
+class Node {
+    constructor(value) {
+      this.value = value;
+      this.left = null;
+      this.right = null;
+    }
+  }
+  
+  // Define the Binary Search Tree class
+  class BinarySearchTree {
+    constructor() {
+      this.root = null;
+    }
+  
+    // Method to insert a new node into the BST
+    insert(value) {
+      const newNode = new Node(value);
+  
+      if (this.root === null) {
+        this.root = newNode;
+      } else {
+        this.insertNode(this.root, newNode);
+      }
+    }
+  
+    insertNode(node, newNode) {
+      if (newNode.value < node.value) {
+        if (node.left === null) {
+          node.left = newNode;
+        } else {
+          this.insertNode(node.left, newNode);
+        }
+      } else {
+        if (node.right === null) {
+          node.right = newNode;
+        } else {
+          this.insertNode(node.right, newNode);
+        }
+      }
+    }
+  
+    // Method to perform binary search
+    search(target) {
+      return this.searchNode(this.root, target);
+    }
+  
+    searchNode(node, target) {
+      if (node === null || node.value === target) {
+        return node;
+      }
+  
+      if (target < node.value) {
+        return this.searchNode(node.left, target);
+      } else {
+        return this.searchNode(node.right, target);
+      }
+    }
+  }
+  
+  // Example usage:
+  const bst = new BinarySearchTree();
+  bst.insert(5);
+  bst.insert(3);
+  bst.insert(8);
+  bst.insert(1);
+  bst.insert(4);
+  bst.insert(7);
+  bst.insert(9);
+
+//   console.log(bst)
+  
+  const targetValue = 10;
+  const result = bst.search(targetValue);
+  
+  if (result) {
+    console.log(`Found ${targetValue} in the BST.`);
+  } else {
+    console.log(`${targetValue} not found in the BST.`);
+  }
+  

Diff for: bst.js

@@ -60,16 +60,16 @@ class Node {
 
   // Example usage:
   const bst = new BinarySearchTree();
-  bst.insert(5);
-  bst.insert(3);
-  bst.insert(8);
-  bst.insert(1);
+   bst.insert(5);
+   bst.insert(3);
+   bst.insert(8);
+   bst.insert(1);
   bst.insert(4);
   bst.insert(7);
-  bst.insert(9);
+   bst.insert(9);
 
 
-  const targetValue = 10;
+  const targetValue = 7;
   const result = bst.search(targetValue);
 
   console.log(bst)

Diff for: trees.js

@@ -17,32 +17,32 @@ this.children.push(Childname)
 }
 
 const familyTree = new Node("Grandpa");
-const dad = new Node("Dad");
-const mom = new Node("Mom");
- familyTree.addChildren(dad);
-// familyTree.addChildren(mom);
-const child1 = new Node("Judy");
+ const dad = new Node("Dad");
+ const mom = new Node("Mom");
+  familyTree.addChildren(dad);
+familyTree.addChildren(mom);
+ const child1 = new Node("Judy");
 const child2 = new Node("James");
-const child3 = new Node("Joyce");
- dad.addChildren(child1);
-// dad.addChildren(child2);
-// mom.addChildren(child3);
+ const child3 = new Node("Joyce");
+  dad.addChildren(child1);
+ dad.addChildren(child2);
+ mom.addChildren(child3);
 
-console.log(familyTree.children[0].children[0].name)
+console.log(familyTree)
 // Function to print the family tree recursively
 function printFamilyTree(node, level = 0) {
     const indentation = "  ".repeat(level); // Add spaces for indentation
 
-   // console.log(`${indentation}- ${node.name}`);
+    console.log(`${indentation}- ${node.name}`);
 
     for (const child of node.children) {
       printFamilyTree(child, level + 1);
     }
   }
 
 //   // Print the family tree
-//   console.log("Family Tree:");
-  // printFamilyTree(familyTree);
+   console.log("Family Tree:");
+   printFamilyTree(familyTree);
 
 //  console.log(familyTree)