Trees presentation (Binary tree and BTS)

Author: solotahoe

Diff for: Dsa.js

@@ -0,0 +1,57 @@
+// 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
+class TreeNode {
+    constructor(value) {
+      this.value = value;
+      this.left = null;
+      this.right = null;
+    }
+  }
+
+//javascript implementation
+  // Helper function to create a binary tree for demonstration purposes   
+function createBinaryTree() {
+    const root = new TreeNode(1);
+    root.left = new TreeNode(2);
+    root.right = new TreeNode(3);
+    root.left.left = new TreeNode(4);
+    root.left.right = new TreeNode(5);
+    root.right.left = new TreeNode(6);
+    root.right.right = new TreeNode(7);
+    return root;
+  }
+
+  
+  //algorithm implementation 
+  // Function to find the maximum depth (height) of a binary tree using recursion
+function maxDepth(root) {
+    if (!root) {
+      return 0;
+    } else {
+      const leftDepth = maxDepth(root.left);
+      // console.log(leftDepth)
+      console.log("leftpath:", leftDepth); 
+      const rightDepth = maxDepth(root.right);
+      // console.log(rightDepth)
+      return 1 + Math.max(leftDepth, rightDepth);
+    }
+  }
+  
+  // Example usage:
+  const root = createBinaryTree();
+  const depth = maxDepth(root);
+  console.log("Maximum Depth of Binary Tree:", depth); // Output: Maximum Depth of Binary Tree: 3
+  
+//   Explanation:
+// In this example, we define a simple binary tree using the TreeNode class. Then, we create a binary tree using the createBinaryTree function. After that, we implement the maxDepth function using recursion to find the maximum depth of the binary tree. The function starts with the root node and recursively calculates the maximum depth of its left and right subtrees. The maximum depth of the binary tree is the maximum value between the depth of the left subtree and the depth of the right subtree, plus 1 to account for the current level.
+
+// In this case, the binary tree has a maximum depth of 3, and the function correctly computes and returns this value.
+
+
+
+
+
+// Regenerate

Diff for: README.md

@@ -0,0 +1,95 @@
+ # 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."
+
+  [image visualization of a tree structure](https://media.geeksforgeeks.org/wp-content/uploads/20221124153129/Treedatastructure.png)
+
+### Most commonly used Types of Trees
+- Binary Tree: A binary tree is a tree data structure where each node has at most two children, referred to as the left child and the right child. Binary trees are commonly used in various algorithms like binary search, binary tree traversals, and binary heap implementations.
+
+- Binary Search Tree (BST): A binary search tree is a binary tree where each node's left child has a value less than the node, and the right child has a value greater than the node. This property makes searching, insertion, and deletion operations efficient
+- Trie (Prefix Tree): A trie is a tree-like data structure used for efficiently storing and searching strings. It is particularly useful for tasks like autocomplete, spell-checking, and searching for words with common prefixes
+
+- N-ary Tree: An N-ary tree is a tree data structure where each node can have more than two children. In contrast to binary trees, N-ary trees allow a variable number of child nodes per parent node
+
+- Heap: Although a heap is not a strict tree data structure, it can be represented as a binary tree. A heap is a specialized tree-based data structure that satisfies the heap property, making it efficient for finding the maximum or minimum element in constant time and for efficiently extracting the extremum element
+
+others
+- AVL Tree
+- Red-Black Tree
+- Segment Tree
+***
+
+ ### Terminologies
+ - Degree - The degree of a node is the total number of children it has
+ - Depth - Depth of a node is the number of edges from the root to that node (depth of root node is always zero)
+
+ - Height - The numbe of edges form the deepest leaf to that node (height of the root node is considered to be the height of the tree)
+
+      
+***
+ - a tree is a non linear data structure compared to arrays, linked lists, stacks and queues which are linear data structures( elements are arranged in a sequential order, and each element has a unique predecessor (except for the first element) and a unique successor (except for the last element) ).
+
+ - non linear - means elements can have multiple predecessors or successors, leading to more complex relationships between elements
+
+ ### Advantages of using non linear data structures e.g trees 
+   1. Flexible Relationships: Non-linear data structures enable multiple relationships between elements. In graphs, nodes can have any number of connections (edges) to other nodes, allowing for more complex and diverse data relationships
+  2. Complex Algorithms: Many advanced algorithms, such as graph algorithms (e.g., Dijkstra's algorithm, breadth-first search, depth-first search), rely on non-linear data structures to solve complex problems efficiently. These algorithms find applications in route planning, network analysis, social networks, and more
+  3. Dynamic Data: Non-linear data structures can handle dynamic data well, as they allow easy insertion and deletion of elements without much disruption to the overall structure
+  4. Hierarchical Representation: Non-linear data structures like trees allow for hierarchical representation, which can model real-world relationships more accurately. For example, an organization's hierarchy, file systems, and family trees can be represented more naturally using trees
+
+  5. Efficient Data Retrieval: Depending on the specific non-linear data structure and the use case, retrieval of specific data elements can be more efficient compared to linear data structures. For instance, in balanced binary search trees, searching for an element takes O(log n) time, which is faster than linear search in an array (O(n))  ... time required to search is propotinal to the size of the data set...
+
+
+### Operations u can use in a BST
+  - insertion
+  - Search
+  - DFS - Depth-First Search - it is a traversal algorithm used to visit all the nodes in a tree or graph data structure
+  - BFS - Breadth-First Search  - it is a traversal algorithm used to visit all the nodes in a tree or graph data structure level by level.
+  - Deletion  - remove a node given its value
+
+
+
+### Trees implementation in software/programs
+
+- Trees are widely used in computer science and programming due to their versatility and efficiency in organizing and representing data in a hierarchical manner.
+ e.g 
+ 1. representing file systems  -  File systems often use BSTs to organize and search for files and directories efficiently.
+ 2. organizing hierarchical data like organizational charts, DOM (NOT A TREEE BUT tree-like structure to represent the hierarchical relationships among HTML elements in a web page, **each HTML element e.g., div, h1,  etc.) is a node in the tree,**
+ 3. implementing search algorithms like binary search trees(most popular implementation)
+ 4. Sorting
+ 5. auto predictions in keyboards e.g Search Autocomplete: Trie (a type of tree) can be used to implement an efficient search autocomplete feature, suggesting products or categories as the user types in the search bar.
+
+ 6. Contacts List: Many contact management applications use BSTs to sort and search contacts by name.
+ 7. Spell Checkers: BSTs are used in spell checkers to efficiently check if a given word is present in the dictionary
+
+
+  ## How to use BTS 
+
+   - There is no built-in method that directly uses a Binary Search Tree (BST). JavaScript provides basic data structures like arrays and objects, but it does not include native support for tree data structures.
+
+   - If you want to use a BST in JavaScript, you'll need to implement it yourself or use a third-party library that provides BST functionality
+
+   - LIBRARIES EXAMPLES INCLUDE bintrees" AND "binary-search-tree
+
+   `````` javascript
+   const bintrees = require('bintrees');
+const { AVLTree } = bintrees;
+
+// Create a new AVLTree
+const bst = new AVLTree((a, b) => a.key - b.key);
+
+// Insert elements
+bst.insert({ key: 10, value: 'data1' });
+bst.insert({ key: 5, value: 'data2' });
+bst.insert({ key: 15, value: 'data3' });
+
+// Search for elements
+const node = bst.find({ key: 5 });
+console.log(node && node.value); // Output: 'data2'
+
+
+
+
+

Diff for: bst.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);
+      }
+    }
+    //helper function
+    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);
+
+  
+  const targetValue = 10;
+  const result = bst.search(targetValue);
+  
+  console.log(bst)
+  if (result) {
+    console.log(`Found ${targetValue} in the BST.`);
+  } else {
+    console.log(`${targetValue} not found in the BST.`);
+  }
+  

Diff for: case.js

@@ -0,0 +1,79 @@
+// Suppose you have a text file containing a list of valid words, each word separated 
+// by a newline character. We can construct a BST with these words where each node 
+// contains a word, and its left child node contains words that come before it in
+//  alphabetical order, while the right child node contains words that come after it.
+
+class Node {
+  constructor(value) {
+    this.value = value;
+    this.left = null;
+    this.right = null;
+  }
+}
+
+class SpellChecker {
+  constructor() {
+    this.root = null;
+  }
+
+  insert(word) {
+    if (!this.root) {
+      this.root = new Node(word);
+    } else {
+      this._insertNode(this.root, word);
+    }
+  }
+ ///helper function
+  _insertNode(node, word) {
+    if (word < node.value) {
+      if (node.left) {
+        this._insertNode(node.left, word);
+      } else {
+        node.left = new Node(word);
+      }
+    } else if (word > node.value) {
+      if (node.right) {
+        this._insertNode(node.right, word);
+      } else {
+        node.right = new Node(word);
+      }
+    }
+  }
+
+  search(word) {
+    return this._searchNode(this.root, word);
+  }
+
+  _searchNode(node, word) {
+    if (!node) {
+      return false;
+    }
+
+    if (word === node.value) {
+      return true;
+    } else if (word < node.value) {
+      return this._searchNode(node.left, word);
+    } else {
+      return this._searchNode(node.right, word);
+    }
+  }
+}
+
+// Usage:
+const spellChecker = new SpellChecker();
+const validWords = ["apple", "banana", "orange", "grape", "pear"];
+
+// Construct the BST
+validWords.forEach((word) => {
+  spellChecker.insert(word);
+});
+
+
+ console.log(spellChecker)
+// Search for a word
+const searchWord = "banana";
+if (spellChecker.search(searchWord)) {
+  console.log(`${searchWord} is a valid word.`);
+} else {
+  console.log(`${searchWord} is not a valid word.`);
+}

Diff for: trees.js

@@ -0,0 +1,52 @@
+// console.log("this should work")
+// Define a Node class to represent each member of the family
+
+class Node {
+    constructor(name){
+    this.name = name;
+    this.children = [];
+    }
+
+//add children function
+addChildren(Childname){
+this.children.push(Childname)
+}
+// Create the family tree
+
+
+}
+
+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 child2 = new Node("James");
+const child3 = new Node("Joyce");
+ dad.addChildren(child1);
+// dad.addChildren(child2);
+// mom.addChildren(child3);
+
+console.log(familyTree.children[0].children[0].name)
+// 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}`);
+  
+    for (const child of node.children) {
+      printFamilyTree(child, level + 1);
+    }
+  }
+  
+//   // Print the family tree
+//   console.log("Family Tree:");
+  // printFamilyTree(familyTree);
+
+//  console.log(familyTree)
+
+
+
+  
+