Binary Tree Vertical Order Traversal - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Draw Vertical Lines

Imagine vertical grid lines over the tree. Root is at column 0, left children subtract 1, right children add 1

BFS Level Traversal

Use BFS to visit buildings level by level (north to south), naturally maintaining proper ordering

Group by Streets

As we visit each building, add it to the appropriate street column in our HashMap

Collect Results

Traverse from westernmost to easternmost street, collecting all buildings in each column

Key Takeaway

🎯 Key Insight: BFS traversal naturally maintains the required ordering (top-to-bottom, left-to-right) while HashMap efficiently groups nodes by their vertical positions, eliminating the need for sorting.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single BFS traversal visits each node exactly once

✓ Linear Growth

Space Complexity

O(n)

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

⚡ Linearithmic Space

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?

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

Approach	Time	Space	Notes
✓ BFS with HashMap (Optimal)	O(n)	O(n)	Use BFS to maintain level order while tracking columns in a HashMap
DFS with Global Sorting	O(n log n)	O(n)	Use DFS to collect all nodes with coordinates, then sort by column, row, and value

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>

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

int** verticalOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    
    int columnMap[2001][1000];
    int columnSizes[2001] = {0};
    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;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single BFS traversal visits each node exactly once

✓ Linear Growth

Space Complexity

O(n)

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

⚡ Linearithmic Space

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?

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

BFS with HashMap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler