Trouble removing some elements of a TreeSet/SortedSet

Question

I've been stuck with this for quite a while, having been able to work around it, but now it's really getting annoying.
I'm using a TreeSet (using a SortedSet to have it synchronized) containing a list of nodes. Each node has a priority value, which is used as a key to sort the set.
I can use this successfully but after some time, when I want to remove a certain node, the call to remove doesn't succeed in removing the element from the set, the element is still in the set after the call. I checked my comparator manytimes, and everything seems to work fine there, I tracked the call and although my node is in the set, when the comparator is called, all the elements of the set don't seem to be tested, and the actual position of the node in the set "ignored" as several other elements.
in fact, I use two TreeSets, but they aren't not using the same comparator, so I don't think I have a conflit in there.
here is a very light version of the node class and the comparators (won't run, but give you an idea of what I'm doing)
Node Class
public class Node {
     protected double priority1;
     protected double priority2;
     int nodeID;
Comparators
private class Comparator1 implements Comparator
  public int compare(Object o1, Object o2)
    Node t1 = (Node)o1;
    Node t2 = (Node)o2;
    if (t1.nodeID == t2.nodeID)
      return 0;
    int diff = (int) (PRIORITY_SAMPLING * (t1.priority1 - t2.priority1));
    if (diff == 0)
      return t1.nodeID - t2.nodeID;
    else
      return diff;
private class Comparator2 implements Comparator
  public int compare(Object o1, Object o2)
    Node t1 = (Node)o1;
    Node t2 = (Node)o2;
    if (t1.nodeID == t2.nodeID)
      return 0;
    int diff = (int) (PRIORITY_SAMPLING * (t1.priority2 - t2.priority2));
    if (diff == 0)
      return t1.nodeID - t2.nodeID;
    else
      return diff;
}at some point, I use the following code to access my sets and exploit their data, having various treatments and stuff
maxPriority1Node = (Node) Queue1.last();
minPriority2Node = (Node) Queue2.first();
while (maxPriority1Node.priority1 > minPriority2Node.priority2)
  if (Count > desiredCount)
    minPriority2Node.merge();
  else
    maxPriority1Node.split();
    maxPriority1Node = (Node) Queue1.last();
    minPriority2Node = (Node) Queue2.first();
}at some point, I'm in the case : Count > desiredCount so I call the merge part, which adds the current node to the Queue1 while removing it from Queue2, but the removal is never done, so the node is still present in Queue2. When I get back from the call, the minPriority2Node is still the same node because it's still in the list, and I end up stuck in an infinite loop.
Can someone help me with this, or explain me what exactly happen when I try to remove the node from the set, which would explain why the node is still in the list after I tried to remove it ?
if you need some more details to understand my problem, just ask, I'll try to give you more informations then.

Answer 1

thanks for you help but, as you have guessed, merge and split do much more things than just dealing with the queues.
But I've found where the problem was.
I had wrongly assuming that the value returned by the comparator was used by the TreeSet, wether in fact, it's only the sign of it which is useful.
In my code, I was using a constant called PRIORITY_SAMPLING, which was an arbitrary int (0xFFFFFF) to convert my double values (the double values could be any value, not just normalized 0.0 to 1.0 values, so I could not use a bigger int value). This constant was used to convert my double value to an int, trying to have enough precision to differenciate approaching value. In fact, the precision of this constant was not sufficient.
now, I don't use the constant, which, in fact, was useless. Because what is important in the comparator result is not the value but the sign, so I can do a simple test between my double values and return -1 or 1.
I had to had a special case for nodes whose priority are equal, so that they get sorted by ID, which is consistent over time.
here are the new comparators :
private class Comparator1 implements Comparator
     public int compare(Object o1, Object o2)
          Node t1 = (Node)o1;
          Node t2 = (Node)o2;
          if (t1.nodeID == t2.nodeID)
               return 0;
          if (t1.priority1 == t2.priority1)
               return t1.nodeID - t2.nodeID;
          else if (t1.priority1 < t2.priority1)
               return -1;
          else
               return 1;
private class Comparator2 implements Comparator
     public int compare(Object o1, Object o2)
          Node t1 = (Node)o1;
          Node t2 = (Node)o2;
          if (t1.nodeID == t2.nodeID)
               return 0;
          if (t1.priority2 == t2.priority2)
               return t1.nodeID - t2.nodeID;
          else if (t1.priority2 < t2.priority2)
               return -1;
          else
               return 1;
}