Vertical Order Traversal of a Binary Tree

Vertical Order Traversal of a Binary Tree - Problem

Given the root of a binary tree, calculate the vertical order traversal of the binary tree.

For each node at position (row, col), its left and right children will be at positions (row + 1, col - 1) and (row + 1, col + 1) respectively. The root of the tree is at (0, 0).

The vertical order traversal of a binary tree is a list of top-to-bottom orderings for each column index starting from the leftmost column and ending on the rightmost column. There may be multiple nodes in the same row and same column. In such a case, sort these nodes by their values.

Return the vertical order traversal of the binary tree.

Input & Output

Example 1 — Basic Tree

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

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

💡 Note: Column -1: node 9 at (1,-1). Column 0: node 3 at (0,0), node 15 at (2,0). Column 1: node 20 at (1,1). Column 2: node 7 at (2,2). Sorted by column from left to right.

Example 2 — Same Position Nodes

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

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

💡 Note: Column -2: node 4. Column -1: node 2. Column 0: nodes 1,5,6 sorted by row then value. Column 1: node 3. Column 2: node 7.

Example 3 — Single Node

$ Input: root = [1]

› Output: [[1]]

💡 Note: Single node at position (0,0), so only one column with one element.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

The key insight is to assign coordinates (row, col) to each node and group them by column. Use DFS or BFS traversal to collect nodes with their positions, then sort within each column by row and value. Best approach uses DFS with HashMap for O(n log n) time and O(n) space.

Common Approaches

✓ BFS Level-by-Level

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

Use BFS traversal to process the tree level by level. For each node, track its column and add it to the appropriate column list. Since BFS processes nodes in row order naturally, we only need to sort within each column by value for nodes at the same position.

Brute Force DFS with Full Sort

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

Use DFS to traverse the tree and collect each node with its (row, col, value). After collecting all nodes, sort them first by column, then by row, then by value. Finally group by column to build the result.

DFS with Column Map

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

Perform DFS traversal and maintain a map of columns to nodes. For each node, add it to the appropriate column list with its row information. After traversal, sort each column's nodes by row then value, and combine columns in order.

BFS Level-by-Level — Algorithm Steps

BFS traverse tree level by level with column tracking
Add each node to its column list with row information
Sort nodes within each column by row then value
Combine columns from leftmost to rightmost

Visualization

Tap to expand

Step-by-Step Walkthrough

BFS Traversal

Process nodes level by level with column tracking

Column Organization

Group nodes by column as we traverse

Final Sorting

Sort within columns and combine

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 QueueItem {
    struct TreeNode* node;
    int row, col;
};

struct ColumnNode {
    int row, val;
};

struct Column {
    int col;
    struct ColumnNode nodes[100];
    int count;
};

struct Column columns[200];
int columnCount = 0;

void parseArray(const char* str, int* arr, int* size, int* nulls) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (strncmp(p, "null", 4) == 0) {
            nulls[*size] = 1;
            arr[(*size)++] = 0;
            p += 4;
        } else {
            nulls[*size] = 0;
            arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
        }
    }
}

struct TreeNode* buildTree(int* arr, int* nulls, int size) {
    if (size == 0 || nulls[0]) return NULL;
    
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = arr[0];
    root->left = NULL;
    root->right = NULL;
    
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int i = 1;
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && !nulls[i]) {
            node->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));
            node->left->val = arr[i];
            node->left->left = NULL;
            node->left->right = NULL;
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && !nulls[i]) {
            node->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
            node->right->val = arr[i];
            node->right->left = NULL;
            node->right->right = NULL;
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

int findColumn(int col) {
    for (int i = 0; i < columnCount; i++) {
        if (columns[i].col == col) return i;
    }
    columns[columnCount].col = col;
    columns[columnCount].count = 0;
    return columnCount++;
}

int compareColumns(const void* a, const void* b) {
    return ((struct Column*)a)->col - ((struct Column*)b)->col;
}

int compareNodes(const void* a, const void* b) {
    struct ColumnNode* na = (struct ColumnNode*)a;
    struct ColumnNode* nb = (struct ColumnNode*)b;
    return na->row - nb->row;
}

int** solution(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    
    columnCount = 0;
    struct QueueItem queue[1000];
    int front = 0, rear = 0;
    
    queue[rear++] = (struct QueueItem){root, 0, 0};
    
    while (front < rear) {
        struct QueueItem item = queue[front++];
        int idx = findColumn(item.col);
        columns[idx].nodes[columns[idx].count].row = item.row;
        columns[idx].nodes[columns[idx].count].val = item.node->val;
        columns[idx].count++;
        
        if (item.node->left) {
            queue[rear++] = (struct QueueItem){item.node->left, item.row + 1, item.col - 1};
        }
        if (item.node->right) {
            queue[rear++] = (struct QueueItem){item.node->right, item.row + 1, item.col + 1};
        }
    }
    
    qsort(columns, columnCount, sizeof(struct Column), compareColumns);
    
    int** result = (int**)malloc(columnCount * sizeof(int*));
    *returnColumnSizes = (int*)malloc(columnCount * sizeof(int));
    *returnSize = columnCount;
    
    for (int i = 0; i < columnCount; i++) {
        qsort(columns[i].nodes, columns[i].count, sizeof(struct ColumnNode), compareNodes);
        result[i] = (int*)malloc(columns[i].count * sizeof(int));
        (*returnColumnSizes)[i] = columns[i].count;
        for (int j = 0; j < columns[i].count; j++) {
            result[i][j] = columns[i].nodes[j].val;
        }
    }
    
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Find the array part after "root":
    char* start = strstr(input, "[");
    if (!start) return 1;
    
    int arr[1000];
    int nulls[1000];
    int size;
    parseArray(start, arr, &size, nulls);
    
    struct TreeNode* root = buildTree(arr, nulls, size);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(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 log n)

BFS visits n nodes, sorting within columns takes O(n log n) total

⚡ Linearithmic

Space Complexity

O(n)

HashMap stores n nodes, BFS queue holds O(w) nodes where w is max width

⚡ Linearithmic Space

89.0K Views

High Frequency

~25 min Avg. Time

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS Level-by-Level — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler