Tree Traversal Inorder Left Root Right in DSA C - Time & Space Complexity

Time Complexity: Tree Traversal Inorder Left Root Right

O(n)

Understanding Time Complexity

We want to understand how the time needed to visit all nodes in a tree grows as the tree gets bigger.

Specifically, we ask: How does the time to do an inorder traversal change with the number of nodes?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

void inorderTraversal(Node* root) {
    if (root == NULL) return;
    inorderTraversal(root->left);
    printf("%d ", root->data);
    inorderTraversal(root->right);
}
    

This code visits each node in the tree in the order: left child, then root, then right child.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Recursive calls visiting each node once.
• How many times: Exactly once per node in the tree.

How Execution Grows With Input

As the number of nodes grows, the function visits each node once, so the work grows directly with the number of nodes.

Input Size (n)	Approx. Operations
10	About 10 visits
100	About 100 visits
1000	About 1000 visits

Pattern observation: The time grows linearly with the number of nodes.

Final Time Complexity

Time Complexity: O(n)

This means the time to complete the traversal grows in direct proportion to the number of nodes in the tree.

Common Mistake

[X] Wrong: "Since the function calls itself twice, the time is exponential like O(2^n)."

[OK] Correct: Each node is visited only once, so the total work is just one visit per node, not doubling each time.

Interview Connect

Understanding this traversal and its time cost helps you explain how tree operations work efficiently, a key skill in many coding tasks.

Self-Check

"What if we changed the traversal to preorder (root, left, right)? How would the time complexity change?"

Practice

1. What is the order of nodes visited in an inorder tree traversal?

easy

A. Left subtree, Root, Right subtree

B. Root, Left subtree, Right subtree

C. Right subtree, Root, Left subtree

D. Root, Right subtree, Left subtree

Solution

1. Step 1: Understand inorder traversal definition

   Inorder traversal visits nodes in the order: left child, root node, then right child.

2. Step 2: Apply the order to the tree

   This means we first visit all nodes in the left subtree, then the root, then all nodes in the right subtree.

3. Final Answer:

   Left subtree, Root, Right subtree -> Option A

4. Quick Check:

   Inorder = Left, Root, Right [OK]

Hint: Remember: Inorder means Left, Root, then Right [OK]

Common Mistakes:

• Confusing inorder with preorder or postorder
• Visiting root before left subtree
• Visiting right subtree before root

2. Which of the following C function prototypes correctly represents an inorder traversal of a binary tree node struct Node?

easy

A. int inorder(struct Node* root);

B. int inorder(struct Node root);

C. void inorder(struct Node root);

D. void inorder(struct Node* root);

Solution

1. Step 1: Identify correct parameter type for tree traversal

   Traversal functions usually take a pointer to the root node to access the tree nodes.

2. Step 2: Check return type and parameter

   Traversal functions typically return void as they print or process nodes during traversal, so void return type with pointer parameter is correct.

3. Final Answer:

   void inorder(struct Node* root); -> Option D

4. Quick Check:

   Traversal uses pointer and void return [OK]

Hint: Traversal functions use pointer to root and void return [OK]

Common Mistakes:

• Passing struct by value instead of pointer
• Using int return type instead of void
• Missing pointer in parameter

3. Given the binary tree below:

    2
   / \
  1   3

What is the output of the inorder traversal function that prints node values?

medium

A. 2 1 3

B. 1 3 2

C. 1 2 3

D. 3 2 1

Solution

1. Step 1: Identify inorder traversal order

   Inorder visits left subtree, then root, then right subtree.

2. Step 2: Apply inorder to given tree

   Left child is 1, root is 2, right child is 3, so output is "1 2 3".

3. Final Answer:

   1 2 3 -> Option C

4. Quick Check:

   Inorder of 2-node tree = 1 2 3 [OK]

Hint: Inorder prints nodes in ascending order for BST [OK]

Common Mistakes:

• Printing root before left subtree
• Printing right subtree before root
• Confusing preorder or postorder output

4. Consider this C code snippet for inorder traversal:

void inorder(struct Node* root) {
    if (root == NULL) return;
    inorder(root->left);
    printf("%d ", root->data);
    inorder(root->right);
}

What is the error if the function prints nodes in preorder instead of inorder?

medium

A. The printf statement is before the left subtree call

B. The base case is missing the NULL check

C. The right subtree call is missing

D. The function is missing a return type

Solution

1. Step 1: Understand traversal order in code

   Inorder prints after left subtree call and before right subtree call.

2. Step 2: Identify cause of preorder output

   If printf is before left subtree call, root prints first, causing preorder output.

3. Final Answer:

   The printf statement is before the left subtree call -> Option A

4. Quick Check:

   Print before left subtree = preorder [OK]

Hint: Print root between left and right calls for inorder [OK]

Common Mistakes:

• Placing print before left subtree call
• Omitting NULL base case
• Forgetting to call right subtree

5. You have a binary search tree with nodes inserted in this order: 5, 3, 7, 2, 4, 6, 8.
What is the inorder traversal output of this tree?

hard

A. 5 3 7 2 4 6 8

B. 2 3 4 5 6 7 8

C. 8 7 6 5 4 3 2

D. 3 2 4 5 6 7 8

Solution

1. Step 1: Build the BST structure

   Insert 5 as root, 3 left of 5, 7 right of 5, 2 left of 3, 4 right of 3, 6 left of 7, 8 right of 7.

2. Step 2: Perform inorder traversal

   Inorder visits nodes in ascending order for BST: 2, 3, 4, 5, 6, 7, 8.

3. Final Answer:

   2 3 4 5 6 7 8 -> Option B

4. Quick Check:

   Inorder of BST = sorted nodes [OK]

Hint: Inorder traversal of BST gives sorted order [OK]

Common Mistakes:

• Listing nodes in insertion order
• Reversing the order
• Skipping nodes in traversal