Codestin Search App

Binary Tree Inorder Traversal - Problem

Given the root of a binary tree, return the inorder traversal of its nodes' values.

In an inorder traversal, we visit nodes in the following sequence: Left subtree → Root → Right subtree. This traversal pattern is particularly useful for Binary Search Trees as it visits nodes in sorted order!

Goal: Traverse the tree and collect all node values in inorder sequence.

Input: Root node of a binary tree (could be null for empty tree)

Output: Array/list of integers representing node values in inorder sequence

Input & Output

example_1.py — Basic Binary Tree

$ Input: [1, null, 2, 3]

› Output: [1, 3, 2]

💡 Note: Tree structure: 1 → (null, 2 → (3, null)). Inorder traversal visits: left subtree (empty), root (1), right subtree (3, 2) = [1, 3, 2]

example_2.py — Empty Tree

$ Input: []

› Output: []

💡 Note: Empty tree has no nodes to traverse, so result is empty array

example_3.py — Single Node

$ Input: [1]

› Output: [1]

💡 Note: Tree with only root node: left subtree (empty), root (1), right subtree (empty) = [1]

Constraints

The number of nodes in the tree is in the range [0, 100]
Node values are in the range [-100, 100]
Follow-up: Can you solve it iteratively without using recursion?

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Begin at the family patriarch, but don't read their name yet

Go Left First

Visit all descendants on the left side first, going as deep as possible

Read Current Person

Only after visiting all left descendants, read the current person's name

Go Right Last

Finally, visit all descendants on the right side

Backtrack Up

Return to parent and repeat the process for remaining subtrees

Key Takeaway

🎯 Key Insight: Inorder traversal naturally produces sorted output for Binary Search Trees, making it essential for many tree algorithms!

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28 Apple 25

The recursive approach is most intuitive, directly implementing the Left-Root-Right pattern. The iterative stack approach provides better control and avoids potential stack overflow. Both have O(n) time complexity and O(h) space complexity, where h is the tree height. Choose recursion for simplicity, iteration for production systems with deep trees.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Traversal (Simple & Elegant)	O(n)	O(h)	Use recursion to naturally follow the Left-Root-Right pattern
Iterative with Stack (Optimal Space Control)	O(n)	O(h)	Use an explicit stack to simulate recursion with better space control

Recursive Traversal (Simple & Elegant) — Algorithm Steps

Check if current node is null, return if so
Recursively traverse left subtree
Add current node's value to result
Recursively traverse right subtree

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin traversal at the root node, but first go left

Go Left First

Recursively traverse the left subtree completely

Process Root

After left subtree is done, process the current node

Go Right Last

Finally, recursively traverse the right subtree

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

// Helper function to create new node
struct TreeNode* newNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// Recursive inorder traversal
void inorder(struct TreeNode* node, int* result, int* index) {
    if (node == NULL) return;
    
    inorder(node->left, result, index);   // Traverse left subtree
    result[(*index)++] = node->val;       // Process current node
    inorder(node->right, result, index);  // Traverse right subtree
}

int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    int* result = (int*)malloc(100 * sizeof(int)); // Assuming max 100 nodes
    int index = 0;
    inorder(root, result, &index);
    *returnSize = index;
    return result;
}

// Simple tree builder for testing
struct TreeNode* buildSimpleTree() {
    // Example: [1,null,2,3] -> 1(null, 2(3, null))
    struct TreeNode* root = newNode(1);
    root->right = newNode(2);
    root->right->left = newNode(3);
    return root;
}

int main() {
    // For simplicity, using a hardcoded example
    struct TreeNode* root = buildSimpleTree();
    
    int returnSize;
    int* result = inorderTraversal(root, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once, where n is the number of nodes

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h. Worst case O(n) for skewed tree, O(log n) for balanced tree

✓ Linear Space

38.9K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Recursive Traversal (Simple & Elegant) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler