Binary Tree Preorder Traversal

Binary Tree Preorder Traversal - Problem

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

In preorder traversal, we visit nodes in the following order:

Root node first
Left subtree
Right subtree

For example, given a tree with root 1, left child 2, and right child 3, the preorder traversal would be [1, 2, 3].

Input & Output

Example 1 — Basic Tree

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

› Output: [1,2,3]

💡 Note: Visit root 1 first, then right subtree. In right subtree: visit 2, then its left child 3. Final order: 1 → 2 → 3

Example 2 — Empty Tree

$ Input: root = []

› Output: []

💡 Note: Empty tree has no nodes, so preorder traversal returns empty array

Example 3 — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: Tree with only root node returns array with just that value

Constraints

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

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 A Apple 28

The key insight is that preorder traversal visits root before children. Recursive approach naturally follows this pattern: visit current node, then left, then right. Iterative approach uses a stack, pushing right child before left (since stack is LIFO). Best approach depends on preference: recursion is cleaner but uses call stack. Time: O(n), Space: O(h)

Common Approaches

✓ Dfs

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

Iterative Stack

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

Use a stack to iteratively traverse the tree. Push right child before left child so left is processed first (stack is LIFO).

Recursive DFS

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

Visit current node first, then recursively traverse left subtree, then right subtree. This naturally follows the preorder pattern.

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;
};

static int result[1000];
static int resultSize;

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) {
    if (!node) return;
    
    result[resultSize++] = node->val;  // Visit root
    dfs(node->left);                   // Visit left subtree
    dfs(node->right);                  // Visit right subtree
}

void solution(struct TreeNode* root) {
    resultSize = 0;
    dfs(root);
}

int parseNumber(char* str, int* pos) {
    while (str[*pos] && (str[*pos] == ' ' || str[*pos] == ',')) (*pos)++;
    if (!str[*pos] || str[*pos] == ']') return 0;
    
    int sign = 1;
    if (str[*pos] == '-') {
        sign = -1;
        (*pos)++;
    }
    
    int num = 0;
    while (str[*pos] && isdigit(str[*pos])) {
        num = num * 10 + (str[*pos] - '0');
        (*pos)++;
    }
    return sign * num;
}

int isNull(char* str, int* pos) {
    while (str[*pos] && (str[*pos] == ' ' || str[*pos] == ',')) (*pos)++;
    if (strncmp(&str[*pos], "null", 4) == 0) {
        *pos += 4;
        return 1;
    }
    return 0;
}

struct TreeNode* buildTree(char* input) {
    int len = strlen(input);
    if (len <= 2) return NULL;
    
    int pos = 1; // Skip '['
    
    if (isNull(input, &pos)) return NULL;
    
    struct TreeNode* root = createNode(parseNumber(input, &pos));
    static struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear && pos < len - 1) {
        struct TreeNode* node = queue[front++];
        
        // Left child
        if (pos < len - 1 && !isNull(input, &pos)) {
            node->left = createNode(parseNumber(input, &pos));
            queue[rear++] = node->left;
        }
        
        // Right child
        if (pos < len - 1 && !isNull(input, &pos)) {
            node->right = createNode(parseNumber(input, &pos));
            queue[rear++] = node->right;
        }
    }
    
    return root;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = '\0';
    
    struct TreeNode* root = buildTree(input);
    solution(root);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("%d", result[i]);
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

89.2K Views

High Frequency

~15 min Avg. Time

2.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