public IntIteratorNode Add(IntIteratorNode element) { size++; heap[size] = element; UpHeap(); return(heap[1]); }
/// <summary> /// (non-Javadoc) /// see com.browseengine.bobo.api.IntFacetIterator#nextInt() /// </summary> /// <returns></returns> public override int NextInt() { if (!HasNext()) { throw new IndexOutOfRangeException("No more facets in this iteration"); } IntIteratorNode node = _queue.Top(); _facet = node.CurFacet; int next = TermIntList.VALUE_MISSING; count = 0; while (HasNext()) { node = _queue.Top(); next = node.CurFacet; if ((next != TermIntList.VALUE_MISSING) && (next != _facet)) { return(_facet); } count += node.CurFacetCount; if (node.Fetch(1)) { _queue.UpdateTop(); } else { _queue.Pop(); } } return(TermIntList.VALUE_MISSING); }
/// <summary> /// This version of the next() method applies the minHits from the facet spec before returning the facet and its hitcount /// </summary> /// <param name="minHits">the minHits from the facet spec for CombinedFacetAccessible</param> /// <returns>The next facet that obeys the minHits</returns> public override string Next(int minHits) { int qsize = _queue.Size(); if (qsize == 0) { _facet = TermIntList.VALUE_MISSING; count = 0; return(null); } IntIteratorNode node = _queue.Top(); _facet = node.CurFacet; count = node.CurFacetCount; while (true) { if (node.Fetch(minHits)) { node = _queue.UpdateTop(); } else { _queue.Pop(); if (--qsize > 0) { node = _queue.Top(); } else { // we reached the end. check if this facet obeys the minHits if (count < minHits) { _facet = TermIntList.VALUE_MISSING; count = 0; return(null); } break; } } int next = node.CurFacet; if (next != _facet) { // check if this facet obeys the minHits if (count >= minHits) { break; } // else, continue iterating to the next facet _facet = next; count = node.CurFacetCount; } else { count += node.CurFacetCount; } } return(Format(_facet)); }
private void UpHeap() { int i = size; IntIteratorNode node = heap[i]; // save bottom node int j = (int)(((uint)i) >> 1); while (j > 0 && (node.CurFacet < heap[j].CurFacet)) { heap[i] = heap[j]; // shift parents down i = j; j = (int)(((uint)j) >> 1); } heap[i] = node; // install saved node }
public CombinedIntFacetIterator(IList <IntFacetIterator> iterators, int minHits) : this(iterators.Count) { _iterators = iterators; foreach (IntFacetIterator iterator in iterators) { IntIteratorNode node = new IntIteratorNode(iterator); if (node.Fetch(minHits)) { _queue.Add(node); } } _facet = TermIntList.VALUE_MISSING; count = 0; }
/// <summary> /// Removes and returns the least element of the PriorityQueue in log(size) /// time. /// </summary> /// <returns></returns> public IntIteratorNode Pop() { if (size > 0) { IntIteratorNode result = heap[1]; // save first value heap[1] = heap[size]; // move last to first heap[size] = null; // permit GC of objects size--; DownHeap(); // adjust heap return(result); } else { return(null); } }
public virtual IntIteratorNode InsertWithOverflow(IntIteratorNode element) { if (size < maxSize) { Put(element); return(null); } else if (size > 0 && !(element.CurFacet < heap[1].CurFacet)) { IntIteratorNode ret = heap[1]; heap[1] = element; AdjustTop(); return(ret); } else { return(element); } }
private void DownHeap() { int i = 1; IntIteratorNode node = heap[i]; // save top node int j = i << 1; // find smaller child int k = j + 1; if (k <= size && (heap[k].CurFacet < heap[j].CurFacet)) { j = k; } while (j <= size && (heap[j].CurFacet < node.CurFacet)) { heap[i] = heap[j]; // shift up child i = j; j = i << 1; k = j + 1; if (k <= size && (heap[k].CurFacet < heap[j].CurFacet)) { j = k; } } heap[i] = node; // install saved node }
public virtual bool Insert(IntIteratorNode element) { return(InsertWithOverflow(element) != element); }
public void Put(IntIteratorNode element) { size++; heap[size] = element; UpHeap(); }
public virtual IntIteratorNode InsertWithOverflow(IntIteratorNode element) { if (size < maxSize) { Put(element); return null; } else if (size > 0 && !(element.CurFacet < heap[1].CurFacet)) { IntIteratorNode ret = heap[1]; heap[1] = element; AdjustTop(); return ret; } else { return element; } }
public virtual bool Insert(IntIteratorNode element) { return InsertWithOverflow(element) != element; }
public IntIteratorNode Add(IntIteratorNode element) { size++; heap[size] = element; UpHeap(); return heap[1]; }
public CombinedIntFacetIterator(IList<IntFacetIterator> iterators, int minHits) : this(iterators.Count) { _iterators = iterators; foreach (IntFacetIterator iterator in iterators) { IntIteratorNode node = new IntIteratorNode(iterator); if (node.Fetch(minHits)) _queue.Add(node); } _facet = TermIntList.VALUE_MISSING; count = 0; }