Is there any way we can store depth/level in a hashmap of level and arraylist of node iterative depth first search?

Question

I know it is some kind of coding challenge, I was trying to solve a problem I solved it using BFS but I want to solve it using dfs too. So is there a way we can store depth with node in Iterative DFS, I know this can be easily achieved using recursion. Here is my progress:

public HashMap<Integer, ArrayList<TreeNode>> getUsingDFS(TreeNode root){
        HashMap<Integer, ArrayList<TreeNode>> map = new HashMap();
    
        List<TreeNode> visited = new ArrayList();
        
        Stack<TreeNode> stack = new Stack();
        stack.add(root);
        int level = 0;
        
        int top = 1;
        
        while(!stack.isEmpty()){
            TreeNode tempNode = stack.pop();

            //level / depth store here.
            map.put(level, map.getOrDefault(level, new ArrayList()).add(tempNode));
            
            
            visited.add(tempNode);
            
            if(tempNode.left != null){
                queue.add(tempNode.left);
            }
            
             if(tempNode.right != null){
                queue.add(tempNode.right);
            }
                
            

        }
    }

Answer 1

Here is how I achieved this.

 public HashMap<Integer, ArrayList<LevelNode>> getUsingDFS(TreeNode root){
        HashMap<Integer, ArrayList<LevelNode>> map = new HashMap();
        
        Queue<LevelNode> queue = new LinkedList();
        queue.add(new LevelNode(root, 0));
        
        while(!queue.isEmpty()){
            LevelNode tempNode = queue.poll();
            
            ArrayList<LevelNode> list = map.getOrDefault(tempNode.level, new ArrayList());
            list.add(tempNode);
            
            map.put(tempNode.level, list);
            
            if(tempNode.node.left != null){
                queue.add(new LevelNode(tempNode.node.left, tempNode.level+1));
            }
            
             if(tempNode.node.right != null){
                queue.add(new LevelNode(tempNode.node.right, tempNode.level+1));
            }
        }
        return map;
 }

class LevelNode{
    TreeNode node;
    int level;
    
    LevelNode(TreeNode node, int level){
        this.level = level;
        this.node = node;
    }
}