Inorder for Vertical Order Traversal

import java.util.*;

// TreeNode definition as before

class Tuple {
    TreeNode node;
    int vertical;
    int level;

    Tuple(TreeNode node, int vertical, int level) {
        this.node = node;
        this.vertical = vertical;
        this.level = level;
    }
}

class Solution {
    public List<List<Integer>> verticalTraversal(TreeNode root) {
        // TreeMap stores the nodes by vertical -> level -> node value
        TreeMap<Integer, TreeMap<Integer, PriorityQueue<Integer>>> map = new TreeMap<>();

        // Start the inorder traversal
        inorder(root, 0, 0, map);

        // Prepare the result list by traversing the map
        List<List<Integer>> result = new ArrayList<>();
        for (TreeMap<Integer, PriorityQueue<Integer>> verticalMap : map.values()) {
            List<Integer> verticalNodes = new ArrayList<>();
            for (PriorityQueue<Integer> nodeQueue : verticalMap.values()) {
                while (!nodeQueue.isEmpty()) {
                    verticalNodes.add(nodeQueue.poll());
                }
            }
            result.add(verticalNodes);
        }

        return result;
    }

    // Inorder traversal method
    private void inorder(TreeNode node, int vertical, int level, TreeMap<Integer, TreeMap<Integer, PriorityQueue<Integer>>> map) {
        if (node == null) {
            return;
        }

        // Traverse left
        inorder(node.left, vertical - 1, level + 1, map);

        // Visit the current node
        if (!map.containsKey(vertical)) {
            map.put(vertical, new TreeMap<>());
        }
        if (!map.get(vertical).containsKey(level)) {
            map.get(vertical).put(level, new PriorityQueue<>());
        }
        map.get(vertical).get(level).add(node.val);

        // Traverse right
        inorder(node.right, vertical + 1, level + 1, map);
    }
}