La file d'attente de priorité Java se comporte étrangement

Question

J'applique une application qui trouve les n événements les plus proches d'un emplacement donné dans un plan (x, y), en fonction de la distance de Manhattan. J'utilise un PriorityQueue max pour stocker les événements trouvés, avec un comparateur de distance de Manhattan. Cette file d'attente devrait toujours avoir l'événement manDistance max comme son coup d'oeil, mais j'ai trouvé que cela n'arrive pas tout le temps. J'ai imprimé les résultats de cette file d'attente en utilisant pq.poll() dans une boucle, et j'ai découvert que la file d'attente n'est pas réorganisée après une suppression, seulement parfois.

Mon comparateur:

public class LocationComparator implements Comparator<Event> { 
private double xCord,yCord; 

public LocationComparator(double x,double y){ 
    xCord=x; 
    yCord=y; 
} 
@Override 
public int compare(Event x,Event y){ 
    double xManDist=Math.abs(x.getxCord()-xCord)+Math.abs(x.getyCord()-yCord); 
    double yManDist=Math.abs(y.getxCord()-xCord)+Math.abs(y.getyCord()-yCord); 
    return (int)(yManDist-xManDist); 
} 
} 

impression dans la principale méthode:

System.out.println(MessageFormat.format("Closest Events to location {0},{1}",x,y)); 
     while (!(events.isEmpty())){ 
      Event temp=events.poll(); 
      System.out.println(temp); 
      System.out.println(temp.calcManDistance(x, y)); 

Sortie:

Closest Events to location 0,0 
name: Event 5 
x: 3.43 
y: -4.97 
8.398549367213874 
name: Event 10 
x: -8.98 
y: -0.49 
9.469052759377341 
name: Event 3 
x: -0.77 
y: 7.92 
8.693576027826397 
name: Event 2 
x: -0.57 
y: -6.56 
7.127381509823561 
name: Event 6 
x: -0.56 
y: -3.38 
3.935261527783056 

Comme vous pouvez le voir, les événements ne sont pas en ordre décroissant! Cependant, parfois ils le sont. Je ne peux pas suivre les causes de ce comportement incohérent. Est-ce que je manque quelque chose?

Si cela est pertinent, je génère la file d'attente dans cette méthode. Je prends mes événements d'une file d'attente de min priorité, où l'événement peek devrait être l'événement le plus proche de l'emplacement sur l'axe des X. Puis je l'ajoute à la file d'attente maxPriorityQueue qui contient les événements les plus proches son peek manDistance est plus élevé que l'événement par rapport à. Si j'atteins un événement avec x supérieur à manDistance de l'événement peek de ma file d'attente maxPriorityQueue, alors j'ai trouvé mes 5 événements les plus proches.

pqTemp - tient tous les événements dans un minPriorityQueue où PEEK est le plus proche de l'emplacement sur l'axe x

les plus proches des événements actuels --holds manDistanceFarthest où PEEK est l'événement avec la distance max manhattan.

public void findClosestEvents(){ 
    int steps=1; 
    PriorityQueue<Event> pqTemp=new PriorityQueue<>(xClosest); 
    manDistFarthest.add(pqTemp.poll()); 
    while (!(pqTemp.isEmpty())){ 
     steps+=1; 
     if (manDistFarthest.size()<5) 
      manDistFarthest.add(pqTemp.poll()); 

     else if (Math.abs(pqTemp.peek().getxCord())>manDistFarthest.peek().calcManDistance(xLoc, yLoc)) 
      break; 
     else 
      if (pqTemp.peek().calcManDistance(xLoc, yLoc)<=manDistFarthest.peek().calcManDistance(xLoc, yLoc)){ 
       manDistFarthest.poll(); 
      manDistFarthest.add(pqTemp.poll()); 
     } 
      else pqTemp.poll(); 
    } 
    System.out.println(MessageFormat.format("Checked {0} events out of {1}.",steps,xClosest.size())); 

} 

Answer 1

Le seul problème que je vois ici est votre distribution à int. Par exemple, si ce delta est inférieur à 1, vous obtiendrez 0, ce qui signifie égal à - ce qui n'est pas vrai. Et je ne comprends pas toute l'image. Comment utilisez-vous votre comparateur dans pqTemp? Peut-être avez-vous un événement comparable?