adding fix #1342 fixing docs for FenWickTree and DepthFirstSearch

Trees/BreadthFirstTreeTraversal.js

@@ -1,21 +1,33 @@
-/*
-  Breadth First Tree Traversal or level order traversal implementation in javascript
-  Author: @GerardUbuntu
-*/
-
+/**
+ * Represents a node in a binary tree.
+ */
 class Node {
+  /**
+   * Creates a new node with the specified data.
+   * @param {*} data The data to be stored in the node.
+   */
   constructor(data) {
     this.data = data
     this.left = null
     this.right = null
   }
 }
 
+/**
+ * Represents a binary tree data structure.
+ */
 class BinaryTree {
+  /**
+   * Creates a new binary tree with an empty root.
+   */
   constructor() {
     this.root = null
   }
 
+  /**
+   * Performs breadth-first traversal of the binary tree iteratively.
+   * @returns {Array} An array containing the data of nodes visited in breadth-first order.
+   */
   breadthFirstIterative() {
     const traversal = []
     if (this.root) {
@@ -34,6 +46,10 @@ class BinaryTree {
     return traversal
   }
 
+  /**
+   * Performs breadth-first traversal of the binary tree recursively.
+   * @returns {Array} An array containing the data of nodes visited in breadth-first order.
+   */
   breadthFirstRecursive() {
     const traversal = []
     const h = this.getHeight(this.root)
@@ -43,7 +59,11 @@ class BinaryTree {
     return traversal
   }
 
-  // Computing the height of the tree
+  /**
+   * Computes the height of the tree starting from the specified node.
+   * @param {Node} node The node from which to compute the height.
+   * @returns {number} The height of the tree.
+   */
   getHeight(node) {
     if (node === null) {
       return 0
@@ -53,6 +73,12 @@ class BinaryTree {
     return lheight > rheight ? lheight + 1 : rheight + 1
   }
 
+  /**
+   * Traverses the specified level of the tree and adds nodes' data to the traversal array.
+   * @param {Node} node The current node being traversed.
+   * @param {number} levelRemaining The remaining level to traverse.
+   * @param {Array} traversal The array to store the traversal result.
+   */
   traverseLevel(node, levelRemaining, traversal) {
     if (node === null) {
       return

Trees/DepthFirstSearch.js

@@ -4,7 +4,12 @@
  * DFS Algorithm for traversing or searching graph data structures.
  */
 
-// traverses a give tree from specified root's value
+/**
+ * Traverses a given tree using Depth-First Search (DFS) algorithm from the specified root's value.
+ * @param {Array} tree The tree data structure represented as an array of nodes.
+ * @param {number} rootValue The value of the root node from which traversal starts.
+ * @returns {Array} An array containing the values of nodes traversed in DFS order.
+ */
 function traverseDFS(tree, rootValue) {
   const stack = []
   const res = []
@@ -23,7 +28,12 @@ function traverseDFS(tree, rootValue) {
   }
   return res.reverse()
 }
-
+/**
+ * Searches for a node with the specified value in the given tree using Depth-First Search (DFS) algorithm.
+ * @param {Array} tree The tree data structure represented as an array of nodes.
+ * @param {number} value The value to search for in the tree nodes.
+ * @returns {Object|null} The node object if found, or null if the value is not found in the tree.
+ */
 function searchDFS(tree, value) {
   const stack = []
   stack.push(tree[0])

Trees/FenwickTree.js

@@ -5,6 +5,12 @@
  */
 
 class FenwickTree {
+  /**
+   * Constructs a Fenwick Tree.
+   * @param {Array} fenwickArray The Fenwick Tree array to be initialized.
+   * @param {Array} array The input array whose prefix sum is to be calculated.
+   * @param {number} n The size of the input array.
+   */
   constructor(feneickArray, array, n) {
     for (let i = 1; i <= n; i++) {
       feneickArray[i] = 0
@@ -14,6 +20,13 @@ class FenwickTree {
     }
   }
 
+  /**
+   * Updates the Fenwick Tree with a new value at the specified index.
+   * @param {Array} fenwickArray The Fenwick Tree array.
+   * @param {number} n The size of the Fenwick Tree array.
+   * @param {number} index The index at which the value is updated.
+   * @param {number} value The new value to be added at the index.
+   */
   update(feneickArray, n, index, value) {
     index = index + 1
     while (index <= n) {