Tree Traversal Algo addition

src/algorithms/tree/inorder-traversal/README.en-IN.md

@@ -0,0 +1,37 @@
+# Inorder Traversal
+
+Inorder traversal is an algorithm for traversing a tree 
+data structures. One starts at 
+the root and explores left branch of tree, root node and then right branch of tree
+
+
+# Inorder Traversal Algorithm
+
+Inorder traversal is an algorithm for traversing tree data structures.The algorithm involves visiting each node in a specific order: left branch, root node, and then the right branch. This ensures that the nodes are visited in ascending order for Binary Search Trees (BST).
+
+## Inorder Traversal Steps
+
+1. **Start at the root node** of the tree.
+2. **Recursively explore the left subtree**:
+    - Move to the left child of the current node.
+    - Repeat the inorder traversal on the left subtree.
+3. **Visit the root node**:
+    - Process the current node (e.g., print its value, apply a callback function).
+4. **Recursively explore the right subtree**:
+    - Move to the right child of the current node.
+    - Repeat the inorder traversal on the right subtree.
+
+
+## Complexities
+
+### Time Complexity
+
+O(N) Where N is number of nodes in Tree
+
+### Space Complexity
+
+O(H) Where H is height of tree
+
+## References
+-  [Wikipedia](https://en.wikipedia.org/wiki/Tree_traversal)
+

src/algorithms/tree/inorder-traversal/__test__/inorderTraversal.test.js

@@ -0,0 +1,33 @@
+import BinarySearchTreeNode from '../../../../data-structures/tree/binary-search-tree/BinarySearchTreeNode';
+import inorderTraversal from '../inoderTraversal';
+
+describe('Inorder Traversal of Binary tree', () => {
+  it('sholud give inorder travsersal of binary tree', () => {
+    // creating BST
+    const bst = new BinarySearchTreeNode(10);
+
+    // inserting values to BST
+    bst.insert(25);
+    bst.insert(-5);
+    bst.insert(11);
+    bst.insert(9);
+    bst.insert(8);
+    bst.insert(15);
+
+    // callback function
+    const callback = jest.fn();
+    inorderTraversal(bst, callback);
+
+    // checking number of times function called
+    expect(callback).toHaveBeenCalledTimes(7);
+
+    // checking values
+    expect(callback.mock.calls[0][0].value).toEqual(-5);
+    expect(callback.mock.calls[1][0].value).toEqual(8);
+    expect(callback.mock.calls[2][0].value).toEqual(9);
+    expect(callback.mock.calls[3][0].value).toEqual(10);
+    expect(callback.mock.calls[4][0].value).toEqual(11);
+    expect(callback.mock.calls[5][0].value).toEqual(15);
+    expect(callback.mock.calls[6][0].value).toEqual(25);
+  });
+});

src/algorithms/tree/inorder-traversal/inoderTraversal.js

@@ -0,0 +1,26 @@
+function inorderTraversalRecursive(root, callback) {
+  if (!root) {
+    return;
+  }
+  // left branch
+  inorderTraversalRecursive(root.left, callback);
+
+  // callback calling
+  callback(root);
+
+  // right branch
+
+  inorderTraversalRecursive(root.right, callback);
+}
+
+/**
+ * --Inorder traversal of binary tree
+ * @param {BinaryTreeNode} root - Root node of binary tree
+ * @param {CallableFunction} callback
+ * - Callback function which calles for each node in inorder traversal
+ * @returns {void}
+ */
+
+export default function inorderTraversal(root, callback) {
+  inorderTraversalRecursive(root, callback);
+}

src/algorithms/tree/postorder-traversal/README.en-IN.md

@@ -0,0 +1,30 @@
+
+# Postorder Traversal Algorithm
+
+Postorder traversal is an algorithm for traversing tree data structures.The algorithm involves visiting each node in a specific order: left branch, right branch and then root node. 
+
+## Postorder Traversal Steps
+
+1. **Start at the root node** of the tree.
+2. **Recursively explore the left subtree**:
+    - Move to the left child of the current node.
+    - Repeat the postorder traversal on the left subtree.
+3. **Recursively explore the right subtree**:
+    - Move to the right child of the current node.
+    - Repeat the postorder traversal on the right subtree.
+2. **Visit the root node**:
+    - Process the current node (e.g., print its value, apply a callback function).
+
+## Complexities
+
+### Time Complexity
+
+O(N) Where N is number of nodes in Tree
+
+### Space Complexity
+
+O(H) Where H is height of tree
+
+## References
+-  [Wikipedia](https://en.wikipedia.org/wiki/Tree_traversal)
+

src/algorithms/tree/postorder-traversal/__test__/postorderTraversal.test.js

@@ -0,0 +1,33 @@
+import BinarySearchTreeNode from '../../../../data-structures/tree/binary-search-tree/BinarySearchTreeNode';
+import postorderTraversal from '../postorderTraversal';
+
+describe('Postorder Traversal of Binary tree', () => {
+  it('sholud give postorder travsersal of binary tree', () => {
+    // creating BST
+    const bst = new BinarySearchTreeNode(10);
+
+    // inserting values to BST
+    bst.insert(25);
+    bst.insert(-5);
+    bst.insert(11);
+    bst.insert(9);
+    bst.insert(8);
+    bst.insert(15);
+
+    // callback function
+    const callback = jest.fn();
+    postorderTraversal(bst, callback);
+
+    // checking number of times function called
+    expect(callback).toHaveBeenCalledTimes(7);
+
+    // checking values
+    expect(callback.mock.calls[0][0].value).toEqual(8);
+    expect(callback.mock.calls[1][0].value).toEqual(9);
+    expect(callback.mock.calls[2][0].value).toEqual(-5);
+    expect(callback.mock.calls[3][0].value).toEqual(15);
+    expect(callback.mock.calls[4][0].value).toEqual(11);
+    expect(callback.mock.calls[5][0].value).toEqual(25);
+    expect(callback.mock.calls[6][0].value).toEqual(10);
+  });
+});

src/algorithms/tree/postorder-traversal/postorderTraversal.js

@@ -0,0 +1,26 @@
+function postorderTraversalRecursive(root, callback) {
+  if (!root) {
+    return;
+  }
+
+  // left branch
+  postorderTraversalRecursive(root.left, callback);
+
+  // right branch
+  postorderTraversalRecursive(root.right, callback);
+
+  // callback calling
+  callback(root);
+}
+
+/**
+     * --postorder traversal of binary tree
+     * @param {BinaryTreeNode} root - Root node of binary tree
+     * @param {CallableFunction} callback
+     * - Callback function which calles for each node in postorder traversal
+     * @returns {void}
+     */
+
+export default function postorderTraversal(root, callback) {
+  postorderTraversalRecursive(root, callback);
+}

src/algorithms/tree/preorder-traversal/README.en-IN.md

@@ -0,0 +1,31 @@
+
+# Preorder Traversal Algorithm
+
+Preorder traversal is an algorithm for traversing tree data structures.The algorithm involves visiting each node in a specific order: root node, left branch, and then the right branch. 
+
+## Preorder Traversal Steps
+
+1. **Start at the root node** of the tree.
+2. **Visit the root node**:
+    - Process the current node (e.g., print its value, apply a callback function).
+3. **Recursively explore the left subtree**:
+    - Move to the left child of the current node.
+    - Repeat the preorder traversal on the left subtree.
+4. **Recursively explore the right subtree**:
+    - Move to the right child of the current node.
+    - Repeat the preorder traversal on the right subtree.
+
+
+## Complexities
+
+### Time Complexity
+
+O(N) Where N is number of nodes in Tree
+
+### Space Complexity
+
+O(H) Where H is height of tree
+
+## References
+-  [Wikipedia](https://en.wikipedia.org/wiki/Tree_traversal)
+

src/algorithms/tree/preorder-traversal/__test__/preorderTraversal.test.js

@@ -0,0 +1,33 @@
+import BinarySearchTreeNode from '../../../../data-structures/tree/binary-search-tree/BinarySearchTreeNode';
+import preorderTraversal from '../preorderTraversal';
+
+describe('Preorder Traversal of Binary tree', () => {
+  it('sholud give Preorder travsersal of binary tree', () => {
+    // creating BST
+    const bst = new BinarySearchTreeNode(10);
+
+    // inserting values to BST
+    bst.insert(25);
+    bst.insert(-5);
+    bst.insert(11);
+    bst.insert(9);
+    bst.insert(8);
+    bst.insert(15);
+
+    // callback function
+    const callback = jest.fn();
+    preorderTraversal(bst, callback);
+
+    // checking number of times function called
+    expect(callback).toHaveBeenCalledTimes(7);
+
+    // checking values
+    expect(callback.mock.calls[0][0].value).toEqual(10);
+    expect(callback.mock.calls[1][0].value).toEqual(-5);
+    expect(callback.mock.calls[2][0].value).toEqual(9);
+    expect(callback.mock.calls[3][0].value).toEqual(8);
+    expect(callback.mock.calls[4][0].value).toEqual(25);
+    expect(callback.mock.calls[5][0].value).toEqual(11);
+    expect(callback.mock.calls[6][0].value).toEqual(15);
+  });
+});

src/algorithms/tree/preorder-traversal/preorderTraversal.js

@@ -0,0 +1,25 @@
+function preorderTraversalRecursive(root, callback) {
+  if (!root) {
+    return;
+  }
+  // callback calling
+  callback(root);
+
+  // left branch
+  preorderTraversalRecursive(root.left, callback);
+
+  // right branch
+  preorderTraversalRecursive(root.right, callback);
+}
+
+/**
+   * --preorder traversal of binary tree
+   * @param {BinaryTreeNode} root - Root node of binary tree
+   * @param {CallableFunction} callback
+   * - Callback function which calles for each node in preorder traversal
+   * @returns {void}
+   */
+
+export default function preorderTraversal(root, callback) {
+  preorderTraversalRecursive(root, callback);
+}

src/data-structures/tree/binary-search-tree/BinarySearchTreeNode.js

@@ -148,4 +148,15 @@ export default class BinarySearchTreeNode extends BinaryTreeNode {
 
     return this.left.findMin();
   }
+
+  /**
+   * Returns max node in Binary search tree
+   * @returns {BinarySearchTreeNode}
+   */
+  findMax() {
+    if (!this || !this.right) {
+      return this;
+    }
+    return this.right.findMax();
+  }
 }

src/data-structures/tree/binary-search-tree/__test__/BinarySearchTreeNode.test.js

@@ -252,4 +252,14 @@ describe('BinarySearchTreeNode', () => {
 
     expect(childNode.parent).toBeNull();
   });
+
+  it('should give max node', () => {
+    const bst = new BinarySearchTreeNode(10);
+    bst.insert(20);
+    bst.insert(-2);
+    bst.insert(4);
+    bst.insert(-10);
+    bst.insert(40);
+    expect(bst.findMax().value).toBe(40);
+  });
 });