Index: src/java/org/apache/lucene/search/FuzzyQuery.java
===================================================================
--- src/java/org/apache/lucene/search/FuzzyQuery.java	(revision 832595)
+++ src/java/org/apache/lucene/search/FuzzyQuery.java	(working copy)
@@ -19,10 +19,10 @@
 
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.util.PriorityQueue;
 import org.apache.lucene.util.ToStringUtils;
 
 import java.io.IOException;
+import java.util.PriorityQueue;
 
 /** Implements the fuzzy search query. The similarity measurement
  * is based on the Levenshtein (edit distance) algorithm.
@@ -132,30 +132,13 @@
       return new TermQuery(term);
     }
 
+    PriorityQueue<ScoreTerm> stQueue = new PriorityQueue<ScoreTerm>(1024);
     FilteredTermEnum enumerator = getEnum(reader);
-    int maxClauseCount = BooleanQuery.getMaxClauseCount();
-    ScoreTermQueue stQueue = new ScoreTermQueue(maxClauseCount);
-    ScoreTerm reusableST = null;
-
     try {
       do {
-        float score = 0.0f;
-        Term t = enumerator.term();
+        final Term t = enumerator.term();
         if (t != null) {
-          score = enumerator.difference();
-          if (reusableST == null) {
-            reusableST = new ScoreTerm(t, score);
-          } else if (score >= reusableST.score) {
-            // reusableST holds the last "rejected" entry, so, if
-            // this new score is not better than that, there's no
-            // need to try inserting it
-            reusableST.score = score;
-            reusableST.term = t;
-          } else {
-            continue;
-          }
-
-          reusableST = stQueue.insertWithOverflow(reusableST);
+          stQueue.offer(new ScoreTerm(t, enumerator.difference()));
         }
       } while (enumerator.next());
     } finally {
@@ -163,9 +146,9 @@
     }
     
     BooleanQuery query = new BooleanQuery(true);
-    int size = stQueue.size();
+    int size = Math.min(stQueue.size(), BooleanQuery.getMaxClauseCount());
     for(int i = 0; i < size; i++){
-      ScoreTerm st = stQueue.pop();
+      ScoreTerm st = stQueue.poll();
       TermQuery tq = new TermQuery(st.term);      // found a match
       tq.setBoost(getBoost() * st.score); // set the boost
       query.add(tq, BooleanClause.Occur.SHOULD);          // add to query
@@ -188,7 +171,7 @@
     return buffer.toString();
   }
   
-  protected static class ScoreTerm {
+  protected static class ScoreTerm implements Comparable<ScoreTerm> {
     public Term term;
     public float score;
     
@@ -196,24 +179,16 @@
       this.term = term;
       this.score = score;
     }
-  }
-  
-  protected static class ScoreTermQueue extends PriorityQueue<ScoreTerm> {
     
-    public ScoreTermQueue(int size){
-      initialize(size);
-    }
-    
-    @Override
-    protected boolean lessThan(ScoreTerm termA, ScoreTerm termB) {
-      if (termA.score == termB.score)
-        return termA.term.compareTo(termB.term) > 0;
+    public int compareTo(ScoreTerm other) {
+      // inverse ordering!!!
+      if (this.score == other.score)
+        return other.term.compareTo(this.term);
       else
-        return termA.score < termB.score;
+        return Float.compare(other.score, this.score);
     }
-    
   }
-
+  
   @Override
   public int hashCode() {
     final int prime = 31;