Replaced old impl. with FixedMinHeap (much faster)

Author: GreenWizard2015

src/YASL/Collectors/KTopCollector.java

@@ -1,80 +1,61 @@
 package YASL.Collectors;
 
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
 import YASL.CEstimatedItems;
 import YASL.CEstimationFor;
 import YASL.IEstimationCollector;
+import YASL.Collectors.Heap.CFixedMinHeap;
+import YASL.Collectors.Heap.CprSimple;
 import YASL.Streams.TypedOutputStream;
 
 public class KTopCollector<T> implements IEstimationCollector<T> {
-	private final int												_K;
-	private long														_min	= 0L;
-	private final List<CEstimationFor<T>>		_items;
-	private final Map<T, CEstimationFor<T>>	_byValue;
+	private static class CTopItem<T> extends CprSimple<T> {
+		public CTopItem(T value, long priority) {
+			super(value, (int) priority);
+		}
 
-	public KTopCollector( //
-	    int _K, //
-	    List<CEstimationFor<T>> _items, //
-	    Map<T, CEstimationFor<T>> _byValue //
-	) {
-		this._K = _K;
-		this._items = _items;
-		this._byValue = _byValue;
+		public void update(long cnt) {
+			_priority = (int) cnt;
+		}
 	}
 
-	public KTopCollector(int K) {
-		this(K, new ArrayList<>(), new HashMap<>());
+	private final CFixedMinHeap<CTopItem<T>, T> _heap;
+
+	public KTopCollector(int size) {
+		this._heap = new CFixedMinHeap<>(size);
 	}
 
 	@Override
 	public void put(T item, long cnt) {
-		if (cnt < _min)
-			return;
-
-		CEstimationFor<T> est = _byValue.get(item);
-		if (null != est) {
-			_items.remove(Collections.binarySearch(_items, est));
+		final CTopItem<T> ratted = _heap.get(item);
+		if (null == ratted) {
+			_heap.add(new CTopItem<T>(item, cnt));
+		} else {
+			ratted.update(cnt);
+			_heap.update(item);
 		}
-
-		est = new CEstimationFor<T>(item, cnt);
-		_byValue.put(item, est);
-		int ind = Collections.binarySearch(_items, est);
-		_items.add(-ind - 1, est);
-
-		if ((_K * 1.5) < _items.size())
-			fitK();
 	}
 
-	private void fitK() {
-		while (_K < _items.size()) {
-			_byValue.remove(_items.remove(_items.size() - 1).Item);
-		}
-
-		if (_items.size() == _K)
-			_min = _items.get(_K - 1).Count;
+	private List<CEstimationFor<T>> items() {
+		return _heap.items() //
+		    .stream() //
+		    .map(x -> new CEstimationFor<>(x.value, x.Priority())) //
+		    .collect(Collectors.toList());
 	}
 
 	@Override
 	public CEstimatedItems<T> collect() {
-		fitK();
-		return new CEstimatedItems<>( //
-		    _items.stream().collect(Collectors.toList()) //
-		);
+		return new CEstimatedItems<>(items());
 	}
 
 	@Override
 	public void store(TypedOutputStream<T> stream) throws IOException {
-		fitK();
-
-		stream.writeInt(_items.size());
-		for (CEstimationFor<T> item : _items) {
+		List<CEstimationFor<T>> items = items();
+		stream.writeInt(items.size());
+		for (CEstimationFor<T> item : items) {
 			stream.writeType(item.Item);
 			stream.writeLong(item.Count);
 		}

src/YASL/Collectors/StoredKTop.java

@@ -1,12 +1,7 @@
 package YASL.Collectors;
 
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
 
-import YASL.CEstimationFor;
 import YASL.Streams.TypedInputStream;
 
 public class StoredKTop<T> {
@@ -18,17 +13,13 @@ public StoredKTop(int _size) {
 
 	public KTopCollector<T> load(TypedInputStream<T> stream) throws IOException {
 		final int cnt = stream.readInt();
-		final List<CEstimationFor<T>> items = new ArrayList<>(cnt);
-		final Map<T, CEstimationFor<T>> byValue = new HashMap<>();
+		final KTopCollector<T> res = new KTopCollector<>(_size);
 
 		for (int i = 0; i < cnt; i++) {
 			final T item = stream.readType();
 			final long itemCount = stream.readLong();
-			final CEstimationFor<T> est = new CEstimationFor<>(item, itemCount);
-
-			items.add(est);
-			byValue.put(item, est);
+			res.put(item, itemCount);
 		}
-		return new KTopCollector<>(_size, items, byValue);
+		return res;
 	}
 }