Beispiel #1
0
        internal static void Sink <T>(this T[] heap, int i, int count, IComparer <T> comparer, int shift)
        {
            int num = count + shift;

            while (true)
            {
                int num2 = i + shift;
                int num3 = 2 * i + shift;
                if (num3 > num)
                {
                    break;
                }
                int  num4 = num3 + 1;
                bool flag = num4 <= num;
                T    x    = heap[num2];
                T    t    = heap[num3];
                T    y    = flag ? heap[num4] : default(T);
                if (comparer.GreaterOrEqual(x, t) && (!flag || comparer.GreaterOrEqual(x, y)))
                {
                    return;
                }
                int num5 = (!flag || comparer.GreaterOrEqual(t, y)) ? num3 : num4;
                heap.Swap(num2, num5);
                i = num5 - shift;
            }
        }
Beispiel #2
0
 internal static void Sift <T>(this T[] heap, int i, IComparer <T> comparer, int shift)
 {
     while (i > 1)
     {
         int num  = i / 2 + shift;
         int num2 = i + shift;
         if (comparer.GreaterOrEqual(heap[num], heap[num2]))
         {
             return;
         }
         heap.Swap(num, num2);
         i = num - shift;
     }
 }
Beispiel #3
0
        protected internal void RemoveAt(int index, int shift)
        {
            var num = index + shift;

            Count--;
            Heap.Swap(num, Count);
            Heap[Count] = default(T);
            var num2 = index / 2 + shift;

            if (_comparer.GreaterOrEqual(Heap[num], Heap[num2]))
            {
                Heap.Sift(index, _comparer, shift);
                return;
            }
            Heap.Sink(index, Count, _comparer, shift);
        }
        /// <summary>
        /// Removes item at given index
        /// </summary>
        /// <param name="index">1-based index of the element to remove</param>
        /// <param name="shift">Shift allows to compensate and work with arrays where heap starts not from the element at position 1.
        /// Shift -1 allows to work with 0-based heap as if it was 1-based. But the main reason for this is the CopyTo method.</param>
        protected internal void RemoveAt(int index, int shift)
        {
            var itemIndex = index + shift;

            Count--;
            _heap.Swap(itemIndex, Count);       // last element at Count
            _heap[Count] = default(T);          // release hold on the object
            // use a 1-based-heap index and then apply shift of -1
            var parent = index / 2 + shift;     // get parent

            // if new item at index is greater than it's parent then sift it up, else sink it down
            if (_comparer.GreaterOrEqual(_heap[itemIndex], _heap[parent]))
            {
                // provide a 1-based-heap index
                _heap.Sift(index, _comparer, shift);
            }
            else
            {
                // provide a 1-based-heap index
                _heap.Sink(index, Count, _comparer, shift);
            }
        }