class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def vertical_order_traversal_brute_force(root):
    node_levels = []

    def calculate_node_levels(node, level):
        if not node:
            return

        node_levels.append((level, node.val))
        calculate_node_levels(node.left, level - 1)
        calculate_node_levels(node.right, level + 1)

    calculate_node_levels(root, 0)

    # Need this to determine what range of levels to iterate through.
    if not node_levels:
        return []

    min_level = min(level for level, _ in node_levels)
    max_level = max(level for level, _ in node_levels)

    vertical_order = []

    # Iterate through each horizontal level
    for level in range(min_level, max_level + 1):
        current_level_nodes = []

        # Collect nodes at the current horizontal level
        for node_level, node_value in node_levels:
            if node_level == level:
                current_level_nodes.append(node_value)

        vertical_order.append(current_level_nodes)

    return vertical_order

from collections import deque

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def vertical_order(root):
    if not root:
        return []

    column_to_nodes = {}
    queue = deque([(root, 0)])

    while queue:
        node, column_index = queue.popleft()

        # Store the node value for the current column index.
        if column_index not in column_to_nodes:
            column_to_nodes[column_index] = []
        column_to_nodes[column_index].append(node.val)

        if node.left:
            queue.append((node.left, column_index - 1))
        if node.right:
            queue.append((node.right, column_index + 1))

    # Get column indexes in sorted order.
    sorted_columns = sorted(column_to_nodes.keys())

    result = []
    # Construct the final result based on the sorted column indexes.
    for column_index in sorted_columns:
        result.append(column_to_nodes[column_index])

    return result