- Trending Categories
- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- MS Excel
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP
- Physics
- Chemistry
- Biology
- Mathematics
- English
- Economics
- Psychology
- Social Studies
- Fashion Studies
- Legal Studies

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

# In-order traversal in Javascript Tree

The tree is a data structure that is comprised of nodes and edges. These entities are interconnected to each other to form a tree structure.

Traversing a data structure means visiting each and every node in that structure and bringing out a sequence of values from that. There are three types of traversals namely, in-order (L→ Root→R ), pre-order(Root→L→R) and, post-order(L→ R → Root)

## In-order Traversal

In the In-order Traversal, the left subtree is visited first, followed by the Root node and finally the right subtree. A binary tree will provide sorted key values in ascending order if it is traversed in-order.

It will represent as

LEFT → ROOT → RIGHT

Consider the following binary search tree,

The traversal starts from the root node **A**, and checks whether the root node **A** has a left subtree. As it exists, it moves to the left subtree, **B**. There is no subtree present after **B, A** (Root node) will be traversed and goes to the right subtree C to check if it has a left subtree. This process will go on until all nodes are traversed.

The output of the above Inorder tree traversal will be −

B → A → D → C → F → E → G

### Algorithm

In order (Tree)

Traverse the left subtree, leftmost node in the tree will be printed first (LeftSubtree).

Goes back to the Root, the root is printed.

Traverse the right subtree, rightmost node will be printed last (Right-Subtree).

### Binary search tree with added nodes

Consider a new scenario where there are more nodes inserted in the tree.

The green arrows in the above figure indicate the direction of the inorder traversal.

The end results of the presented binary tree are as follows: D→ B→ E→ A→ H→ F→ I→ C→ G

## Example 1 (Using Recursion)

The following code provides a description of the in order tree traversal with recursion technique.

<!DOCTYPE html> <html> <head> <script> class Node { constructor(value) { this.key = value; this.left = null; this.right = null; } } var root = null; function TreeInorder(node) { if (node == null) return; TreeInorder(node.left); document.write(node.key + "→"); TreeInorder(node.right); } root = new Node('A'); root.left = new Node('B'); root.right = new Node('C'); root.right.left = new Node('D'); root.right.right = new Node('E'); root.right.right.left = new Node('F'); root.right.right.right = new Node('G'); document.write("<br/>Inorder traversal of the tree is<br/>"); TreeInorder(root); </script> </head> </html>

### Output

The output of the above script will be −

```
Inorder traversal of the tree is
B → A → D → C → F → E → G →
```

## Example 2 (Using Stack)

Another way to traverse tree in in-order technique can be done using stack.

<!DOCTYPE html> <html> <head> <script> class Node { constructor(stack) { this.data = stack; this.left = this.right = null; } } var root_Node; function inorderUsingStack() { if (root_Node == null) return; let stack = []; let current_Node = root_Node; while (current_Node != null || stack.length > 0) { while (current_Node != null) { stack.push(current_Node); current_Node = current_Node.left; } current_Node = stack.pop(); document.write(current_Node.data + "→"); current_Node = current_Node.right; } } root_Node = new Node('A'); root_Node.left = new Node('B'); root_Node.right = new Node('C'); root_Node.right.left = new Node('D'); root_Node.right.right = new Node('E'); root_Node.right.right.left = new Node('F'); root_Node.right.right.right = new Node('G'); inorderUsingStack(); </script> </head> </html>

### Output

The output of the above script will be −

```
B → A → D → C → F → E → G →
```

- Related Articles
- Pre-order traversal in a Javascript Tree
- Level Order Tree Traversal in Data Structures
- Binary Tree Level Order Traversal in C++
- Binary Tree Vertical Order Traversal in C++
- Binary Tree Zigzag Level Order Traversal in Python
- N-ary Tree Level Order Traversal in C++
- Program to perform level order traversal of binary tree in C++
- Find the kth node in vertical order traversal of a Binary Tree in C++
- Zig Zag Level order traversal of a tree using single queue in C++
- Program to convert level order binary tree traversal to linked list in Python
- ZigZag Tree Traversal in C++
- C++ Program to Implement Double Order Traversal of a Binary Tree
- Postorder Tree Traversal in Data Structures
- Preorder Tree Traversal in Data Structures
- Binary Tree Inorder Traversal in Python