Inorder traversal technique addition

Author: RaviSadam

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);
+}