Question

我正在尝试解决此exercise，这是我的解决方案。它基本上拥有一个树形图，以将相同垂直偏移量的节点映射到一个键。并使用一个优先级队列，使用节点上的值在同一（水平级别）有多个键时拆分关系。

public List<List<Integer>> verticalTraversal(TreeNode root) {
    Map<Integer, PriorityQueue<Node>> map = new TreeMap<>();
    List<List<Integer>> out = new ArrayList<>();
    if(root == null)
        return out;
    Queue<Node> q = new LinkedList<>();
    Node r = new Node(root, 0, 0);
    q.add(r);
    while(!q.isEmpty()) {
        Node curr = q.remove();
        int x = curr.x;
        int y = curr.y;
        PriorityQueue<Node> pq = map.getOrDefault(y, new PriorityQueue<Node>((a,b) ->(a.x == b.x? a.t.val - b.t.val: a.x - b.x)));
        pq.add(curr);
        map.put(y,pq);
        if(curr.t.left!=null){
            Node left = new Node(curr.t.left, x+1, y-1);
            q.add(left);
        }
        if(curr.t.right!=null){
            Node right = new Node(curr.t.right, x+1, y + 1);
            q.add(right);
        }
    }
for (Map.Entry<Integer, PriorityQueue<Node>> entry : map.entrySet()){
   PriorityQueue<Node> pq = entry.getValue();
    List<Integer> vals = new ArrayList<>();
   for (Node pqNode: pq){
       vals.add(pqNode.t.val);                       

   }
out.add(new ArrayList<Integer>(vals));

}
return out;
}




class Node {
    TreeNode t;
    int y;
    int x;
    Node(TreeNode t, int x, int y) {
        this.t = t;
        this.x = x;
        this.y = y; 
    }
}

}

要明确的是，我认为问题出在哪里

  PriorityQueue<Node> pq = map.getOrDefault(y, new PriorityQueue<Node>((a,b) ->(a.x == b.x? a.t.val - b.t.val: a.x - b.x)));

当a.x不等于b.x时，我得到了预期的顺序，但是当它们相等时，似乎并没有经过val。

这是失败的测试用例实际：[ [7,9] ，[5,6]，[0,2,4]，[1,3]，[8]] 预期：[[ 9,7] ，[5,6]，[0,2,4]，[1,3]，[8]]

Answer 1

您做错了，您遍历了优先级队列的各个元素，而不是对其进行轮询。

PriorityQueue#iterator()的文档明确指出：

返回此队列中元素的迭代器。迭代器不会以任何特定顺序返回元素。

代替写作

for (Node pqNode: pq){
    vals.add(pqNode.t.val);                       
}

您应该使用：

Node pqNode;
while ((pqNode = pq.poll()) != null) {
    vals.add(pqNode.t.val);                       
}

Java 8 PriorityQueue比较器在做什么？

1 个答案: