Binary Tree Vertical Order Traversal

Binary Tree Vertical Order Traversal - Problem

Imagine looking at a binary tree from above and dropping vertical lines through each node position. Your task is to collect all the nodes that fall on the same vertical line, from left to right, and within each vertical line, collect nodes from top to bottom.

Given the root of a binary tree, return the vertical order traversal of its nodes' values. This means grouping nodes by their horizontal distance from the root, where:

Root is at position 0
Left children are at position parent - 1
Right children are at position parent + 1
Nodes in the same column should be ordered top to bottom
If two nodes are at the same position (row and column), order them left to right

Example: For a tree with root value 3, left child 9, and right child 20 (with 20 having children 15 and 7), the vertical order would be [[9], [3, 15], [20], [7]]

Input & Output

example_1.py — Basic Tree

$ Input: root = [3,9,20,null,null,15,7]

› Output: [[9],[3,15],[20],[7]]

💡 Note: Root 3 is at column 0. Left child 9 at column -1. Right child 20 at column 1. Node 15 (left child of 20) at column 0, and node 7 (right child of 20) at column 2.

example_2.py — Single Node

$ Input: root = [1]

› Output: [[1]]

💡 Note: Single node tree results in one column containing just the root value.

example_3.py — Same Column Multiple Nodes

$ Input: root = [1,2,3,4,6,5,7]

› Output: [[4],[2],[1,5,6],[3],[7]]

💡 Note: Multiple nodes can share the same column. They are ordered top to bottom, and left to right if at the same level.

Constraints

The number of nodes in the tree is in the range [0, 100]
Node values are in the range [-100, 100]
Follow-up: What if nodes at the same position need different ordering rules?

Visualization

Tap to expand

Asked in

f Facebook 45 G Google 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses BFS traversal with a HashMap to group nodes by column position. BFS naturally maintains the required top-to-bottom and left-to-right ordering, achieving O(n) time complexity without needing to sort the results.

Common Approaches

✓ BFS with HashMap (Optimal)

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

This optimal approach uses breadth-first search (BFS) to traverse the tree level by level, which naturally maintains the top-to-bottom ordering requirement. During traversal, we track each node's column position and use a HashMap to group nodes by column. BFS ensures that nodes at the same level are processed left-to-right, automatically handling the ordering requirements.

DFS with Global Sorting

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

This approach uses depth-first search to traverse the entire tree and collect each node along with its column and row coordinates. After collecting all nodes, it sorts them first by column (vertical position), then by row (level), and finally by value (for nodes at same position).

BFS with HashMap (Optimal) — Algorithm Steps

Initialize BFS queue with root at column 0
Use HashMap to group nodes by column while traversing
Process nodes level by level (BFS maintains correct row order)
Track min and max columns to determine final ordering
Build result by iterating through columns from min to max

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize BFS

Start with root at column 0 in queue

Process Level by Level

BFS ensures top-to-bottom and left-to-right ordering

Group by Columns

HashMap groups nodes by their column positions

Code -

solution.c — C

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

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

struct QueueNode {
    struct TreeNode* node;
    int col;
    struct QueueNode* next;
};

struct Queue {
    struct QueueNode* front;
    struct QueueNode* rear;
};

struct Queue* createQueue() {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->front = q->rear = NULL;
    return q;
}

void enqueue(struct Queue* q, struct TreeNode* node, int col) {
    struct QueueNode* temp = (struct QueueNode*)malloc(sizeof(struct QueueNode));
    temp->node = node;
    temp->col = col;
    temp->next = NULL;
    
    if (q->rear == NULL) {
        q->front = q->rear = temp;
        return;
    }
    
    q->rear->next = temp;
    q->rear = temp;
}

struct QueueNode* dequeue(struct Queue* q) {
    if (q->front == NULL) return NULL;
    
    struct QueueNode* temp = q->front;
    q->front = q->front->next;
    
    if (q->front == NULL) q->rear = NULL;
    
    return temp;
}

struct TreeNode* buildTree(char** arr, int size) {
    if (size == 0 || strcmp(arr[0], "null") == 0) {
        return NULL;
    }
    
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = atoi(arr[0]);
    root->left = root->right = NULL;
    
    struct Queue* q = createQueue();
    enqueue(q, root, 0);
    int i = 1;
    
    while (q->front != NULL && i < size) {
        struct QueueNode* current = dequeue(q);
        struct TreeNode* node = current->node;
        
        if (i < size && strcmp(arr[i], "null") != 0) {
            node->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));
            node->left->val = atoi(arr[i]);
            node->left->left = node->left->right = NULL;
            enqueue(q, node->left, 0);
        }
        i++;
        
        if (i < size && strcmp(arr[i], "null") != 0) {
            node->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
            node->right->val = atoi(arr[i]);
            node->right->left = node->right->right = NULL;
            enqueue(q, node->right, 0);
        }
        i++;
        
        free(current);
    }
    
    free(q);
    return root;
}

static int columnMap[2001][1000];
static int columnSizes[2001];

int** verticalOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    
    memset(columnSizes, 0, sizeof(columnSizes));
    int minCol = 0, maxCol = 0;
    int offset = 1000;
    
    struct Queue* q = createQueue();
    enqueue(q, root, 0);
    
    while (q->front != NULL) {
        struct QueueNode* current = dequeue(q);
        struct TreeNode* node = current->node;
        int col = current->col;
        
        columnMap[col + offset][columnSizes[col + offset]++] = node->val;
        
        if (col < minCol) minCol = col;
        if (col > maxCol) maxCol = col;
        
        if (node->left) enqueue(q, node->left, col - 1);
        if (node->right) enqueue(q, node->right, col + 1);
        
        free(current);
    }
    
    *returnSize = maxCol - minCol + 1;
    int** result = (int**)malloc(*returnSize * sizeof(int*));
    *returnColumnSizes = (int*)malloc(*returnSize * sizeof(int));
    
    for (int i = 0; i < *returnSize; i++) {
        int col = minCol + i;
        (*returnColumnSizes)[i] = columnSizes[col + offset];
        result[i] = (int*)malloc((*returnColumnSizes)[i] * sizeof(int));
        
        for (int j = 0; j < (*returnColumnSizes)[i]; j++) {
            result[i][j] = columnMap[col + offset][j];
        }
    }
    
    free(q);
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    char* arr[1000];
    int size = 0;
    
    if (strcmp(input, "[]\n") != 0) {
        char* token = strtok(input, ",\n");
        while (token != NULL) {
            arr[size++] = token;
            token = strtok(NULL, ",\n");
        }
    }
    
    struct TreeNode* root = buildTree(arr, size);
    int returnSize;
    int* returnColumnSizes;
    int** result = verticalOrder(root, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single BFS traversal visits each node exactly once

⚡ Linearithmic

Space Complexity

O(n)

O(n) for HashMap storage + O(w) for BFS queue where w is maximum width

⚡ Linearithmic Space

42.3K Views

High Frequency

~18 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

BFS with HashMap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler