Binary Tree Inorder Traversal

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 the nodes in the following order:

Traverse the left subtree
Visit the root node
Traverse the right subtree

For example, given the tree [1,null,2,3], the inorder traversal would be [1,3,2].

Input & Output

Example 1 — Simple Tree

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

› Output: [1,3,2]

💡 Note: Inorder traversal: no left child of 1, visit 1, then go right to 2. For node 2: visit left child 3 first, then visit 2, no right child. Result: [1,3,2]

Example 2 — Empty Tree

$ Input: root = []

› Output: []

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

Example 3 — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: Single node tree: no left child, visit root 1, no right child. Result: [1]

Constraints

The number of nodes in the tree is in the range [0, 100]
-100 ≤ Node.val ≤ 100

Visualization

Tap to expand

Asked in

f Facebook 52 M Microsoft 38 a Amazon 31 G Google 28

Binary tree inorder traversal visits nodes in left → root → right order. The recursive approach is most intuitive, while the iterative stack approach avoids potential stack overflow. Both have O(n) time and O(h) space complexity. Best approach depends on tree depth constraints.

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Iterative Stack Approach

⏱️ Time: O(n) Space: O(h)

Convert the recursive approach to iterative using a stack. We push nodes and traverse left as far as possible, then pop and process nodes, moving to their right subtree.

Recursive Approach

⏱️ Time: O(n) Space: O(h)

The most intuitive approach using recursion. For each node, we recursively traverse the left subtree, add the current node's value to our result, then recursively traverse the right subtree.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

void dfs(struct TreeNode* node, int parentVal, int currentLength, int* maxLength) {
    if (!node) return;
    
    // Check if current node continues the sequence
    if (node->val == parentVal + 1) {
        currentLength++;
    } else {
        currentLength = 1; // Start new sequence
    }
    
    // Update maximum length found
    if (currentLength > *maxLength) {
        *maxLength = currentLength;
    }
    
    // Continue DFS with current node as parent
    dfs(node->left, node->val, currentLength, maxLength);
    dfs(node->right, node->val, currentLength, maxLength);
}

int solution(struct TreeNode* root) {
    if (!root) return 0;
    
    int maxLength = 0;
    dfs(root, root->val - 1, 0, &maxLength);
    return maxLength;
}

struct TreeNode* buildTree(char* input) {
    if (!input || strlen(input) < 3) return NULL;
    
    // Remove brackets and parse
    char* start = strchr(input, '[');
    char* end = strchr(input, ']');
    if (!start || !end) return NULL;
    
    start++; // Skip '['
    *end = '\0'; // Null terminate at ']'
    
    char* tokens[30000];
    int tokenCount = 0;
    
    char* token = strtok(start, ",");
    while (token && tokenCount < 30000) {
        // Trim whitespace
        while (*token == ' ') token++;
        tokens[tokenCount++] = token;
        token = strtok(NULL, ",");
    }
    
    if (tokenCount == 0) return NULL;
    
    // Check if first token is null
    if (strcmp(tokens[0], "null") == 0) return NULL;
    
    struct TreeNode* root = createNode(atoi(tokens[0]));
    struct TreeNode* queue[30000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int i = 1;
    while (front < rear && i < tokenCount) {
        struct TreeNode* node = queue[front++];
        
        // Left child
        if (i < tokenCount && strcmp(tokens[i], "null") != 0) {
            node->left = createNode(atoi(tokens[i]));
            queue[rear++] = node->left;
        }
        i++;
        
        // Right child
        if (i < tokenCount && strcmp(tokens[i], "null") != 0) {
            node->right = createNode(atoi(tokens[i]));
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    line[strcspn(line, "\n")] = '\0';
    
    struct TreeNode* root = buildTree(line);
    int result = solution(root);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

892.0K Views

High Frequency

~15 min Avg. Time

11.2K 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