Tree Traversal Inorder Left Root Right in DSA Javascript - Execution Trace

Concept Flow - Tree Traversal Inorder Left Root Right

Start at root node

↓

Traverse left subtree

↓

Visit current node (root)

↓

Traverse right subtree

↓

End traversal

Inorder traversal visits the left subtree first, then the root node, and finally the right subtree.

Execution Sample

DSA Javascript

function inorder(node) {
  if (node === null) return;
  inorder(node.left);
  console.log(node.value);
  inorder(node.right);
}

This code prints the values of a binary tree in inorder sequence: left child, root, then right child.

Execution Table

Step	Operation	Node Visited	Pointer Changes	Tree State (Visual)
1	Start at root	10	current = 10	10 / \ 5 15
2	Traverse left subtree	5	current = 5	10 / \ 5 15
3	Traverse left subtree	null	current = null	10 / \ 5 15
4	Visit node	5	print 5	10 / \ 5 15
5	Traverse right subtree	null	current = null	10 / \ 5 15
6	Return to root	10	current = 10	10 / \ 5 15
7	Visit node	10	print 10	10 / \ 5 15
8	Traverse right subtree	15	current = 15	10 / \ 5 15
9	Traverse left subtree	null	current = null	10 / \ 5 15
10	Visit node	15	print 15	10 / \ 5 15
11	Traverse right subtree	null	current = null	10 / \ 5 15
12	Traversal complete	null	current = null	10 / \ 5 15

💡 Traversal ends when all nodes have been visited and current pointer is null.

Variable Tracker

Variable	Start	After Step 2	After Step 6	After Step 8	Final
current	10 (root)	5 (left child)	10 (root)	15 (right child)	null (end)
printed_values	[]	[]	[5]	[5, 10]	[5, 10, 15]

Key Moments - 3 Insights

Why do we visit the left subtree before the root node?

In the execution_table at steps 2 and 4, we see the traversal goes left first to node 5 before printing it, ensuring left nodes are processed before the root.

What happens when the current node is null?

At steps 3, 5, 9, and 11, current becomes null, which means there is no child node to visit, so the function returns and backtracks to the previous node.

Why do we print the node value after traversing the left subtree?

Step 4 shows printing after left traversal, ensuring the left subtree is fully processed before visiting the root, following the inorder rule.

Visual Quiz - 3 Questions

Look at the execution_table, what is the printed value at step 7?

A 10

B 5

C 15

D null

💡 Hint

Check the 'Operation' and 'Node Visited' columns at step 7 in the execution_table.

At which step does the traversal visit the right child of the root node?

A Step 2

B Step 8

C Step 6

D Step 10

💡 Hint

Look for 'Traverse right subtree' operation and 'Node Visited' being 15 in the execution_table.

If the left child of the root was null, how would the printed values change?

A [5, 10, 15]

B [15, 10, 5]

C [10, 15]

D [10]

💡 Hint

Refer to variable_tracker and consider what happens when left subtree traversal is skipped.

Concept Snapshot

Inorder traversal visits nodes in Left → Root → Right order.
Use recursion: traverse left subtree, visit node, traverse right subtree.
Print node value after left subtree is done.
Useful for binary search trees to get sorted order.
Stops when all nodes are visited (null reached).

Full Transcript

Inorder traversal means visiting the left child first, then the root node, and finally the right child. The code uses recursion to go as far left as possible, then prints the node's value, and then goes right. The execution table shows each step: starting at root 10, going left to 5, printing 5, returning to 10, printing 10, then going right to 15 and printing 15. When a node is null, the function returns and backtracks. This traversal order is useful because it prints nodes in sorted order for binary search trees.