I'm implementing BFS traversal for a nested comment tree in Java 17. The input is
a flat list of nodes, each with an `id` and a `parentId`. I first build a
`HashMap>` to index children by parent, then traverse the tree.

I've seen two working implementations and I'm unsure which to prefer:

Approach A — ArrayDeque as queue + separate result list

java
public List bfs(List nodes) {
    Map> byParent = new HashMap<>();
    PlainNode root = null;
    for (PlainNode n : nodes) {
        if (n.parentId() == null) { root = n; continue; }
        byParent.computeIfAbsent(n.parentId(), k -> new ArrayList<>()).add(n);
    }
    List result = new ArrayList<>();
    Deque queue = new ArrayDeque<>();
    queue.add(root);
    while (!queue.isEmpty()) {
        PlainNode curr = queue.poll();
        result.add(curr);
        queue.addAll(byParent.getOrDefault(curr.id(), List.of()));
    }
    return result;
}

Approach B — ArrayList reused as queue via a front index pointe

public List bfs(List nodes) {
    // ... same indexing step ...
    List queue = new ArrayList<>();
    int front = 0;
    queue.add(root);
    while (front < queue.size()) {
        PlainNode curr = queue.get(front++);
        queue.addAll(byParent.getOrDefault(curr.id(), List.of()));
    }
    return queue; // already in BFS order — no separate result list needed
}

Both produce the same result. Is there a real performance difference for trees with ~1000 nodes? Which is considered idiomatic Java?