Port to netstandard.

Nit fixes.
Fixed e2e tests.
Added MIT license.

SystemExtensions.NetStandard/Collections/BinaryHeap.cs

@@ -0,0 +1,214 @@
+using System.Linq;
+
+namespace System.Collections.Generic
+{
+    /// <summary>
+    /// Binary heap implementation.
+    /// </summary>
+    /// <typeparam name="T">Provided type.</typeparam>
+    [Serializable]
+    public sealed class BinaryHeap<T> : IEnumerable<T> where T : IComparable<T>
+    {
+        #region Fields
+        T[] items;
+        private int capacity;
+        private int count;
+        private readonly int initialCapacity;
+        #endregion
+        #region Properties
+        /// <summary>
+        /// Minimum value from the heap.
+        /// </summary>
+        public T Min
+        {
+            get
+            {
+                return items[1];
+            }
+        }
+        /// <summary>
+        /// Maximum value from the heap.
+        /// </summary>
+        public T Max
+        {
+            get
+            {
+                return items[count];
+            }
+        }
+        /// <summary>
+        /// Capacity of the heap.
+        /// </summary>
+        public int Capacity
+        {
+            get => capacity;
+            set
+            {
+                if (value > capacity)
+                {
+                    Array.Resize(ref items, value);
+                    capacity = value;
+                }
+            }
+        }
+        /// <summary>
+        /// Number of elements in the heap.
+        /// </summary>
+        public int Count { get => count; }
+        #endregion
+        #region Constructors
+        /// <summary>
+        /// Constructor for a binary heap data structure.
+        /// </summary>
+        public BinaryHeap()
+        {
+            capacity = 10;
+            initialCapacity = capacity;
+            items = new T[capacity];
+        }
+        /// <summary>
+        /// Constructor for a binary heap data structure.
+        /// </summary>
+        /// <param name="capacity">Initial capacity of the heap. Used for initial alocation of the array.</param>
+        public BinaryHeap(int capacity)
+        {
+            this.capacity = capacity;
+            initialCapacity = capacity;
+            items = new T[capacity];
+        }
+        #endregion
+        #region Public Methods
+        /// <summary>
+        /// Adds value to the queue.
+        /// </summary>
+        /// <param name="value">Value to be added.</param>
+        public void Add(T value)
+        {
+            if (count == Capacity - 1)
+            {
+                Capacity = 2 * Capacity;
+            }
+            int position = ++count;
+            for (; position > 1 && value.CompareTo(items[position / 2]) < 0; position /= 2)
+            {
+                items[position] = items[position / 2];
+            }
+            items[position] = value;
+        }
+        /// <summary>
+        /// Removes the item at the root. Throws exception if there are no items in the heap.
+        /// </summary>
+        /// <returns>Value removed.</returns>
+        public T Remove()
+        {
+            if (count == 0)
+            {
+                throw new IndexOutOfRangeException("Heap is empty!");
+            }
+            T min = items[1];
+            items[1] = items[count--];
+            BubbleDown(1);
+            return min;
+        }
+        /// <summary>
+        /// Peeks at the item at the root. Throws exception if there are no items in the heap.
+        /// </summary>
+        /// <returns></returns>
+        public T Peek()
+        {
+            if (count == 0)
+            {
+                throw new IndexOutOfRangeException("Heap is empty!");
+            }
+            T min = items[1];
+            return min;
+        }
+        /// <summary>
+        /// Return the heap structure as an array
+        /// </summary>
+        /// <returns>Array with values sorted as in heap</returns>
+        public T[] ToArray()
+        {
+            T[] newArray = new T[count];
+            Array.Copy(items, 1, newArray, 0, count);
+            return newArray;
+        }
+        /// <summary>
+        /// Determines whether the heap contains specified value
+        /// </summary>
+        /// <param name="value">Value to locate in the heap</param>
+        /// <returns></returns>
+        public bool Contains(T value)
+        {
+            return items.Contains(value);
+        }
+        /// <summary>
+        /// Clears the heap
+        /// </summary>
+        public void Clear()
+        {
+            count = 0;
+        }
+        /// <summary>
+        /// Clears the heap.
+        /// </summary>
+        /// <param name="completeClear">Specifies if the underlying array should be cleared as well</param>
+        public void Clear(bool completeClear)
+        {
+            count = 0;
+            if (completeClear)
+            {
+                capacity = initialCapacity;
+                items = new T[initialCapacity];
+            }
+        }
+        /// <summary>
+        /// Returns an enumerator that iterates over the heap.
+        /// </summary>
+        /// <returns>Enumerator that iterates over the heap.</returns>
+        public IEnumerator<T> GetEnumerator()
+        {
+            for (int i = 0; i < count; i++)
+            {
+                yield return items[i + 1];
+            }
+        }
+        #endregion
+        #region Private Methods
+        /// <summary>
+        /// Bubble the specified element to its position
+        /// </summary>
+        /// <param name="index">Index of element to bubble</param>
+        private void BubbleDown(int index)
+        {
+            T temp = items[index];
+            int childIndex;
+            for (; 2 * index <= count; index = childIndex)
+            {
+                childIndex = 2 * index;
+                if (childIndex != Count && items[childIndex].CompareTo(items[childIndex + 1]) > 0)
+                {
+                    childIndex++;
+                }
+                if (temp.CompareTo(items[childIndex]) > 0)
+                {
+                    items[index] = items[childIndex];
+                }
+                else
+                {
+                    break;
+                }
+            }
+            items[index] = temp;
+        }
+        /// <summary>
+        /// Implementation of IEnumerator.
+        /// </summary>
+        /// <returns>Enumerator over the array.</returns>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            throw new NotImplementedException();
+        }
+        #endregion
+    }
+}