Fibonacci, Binary, or Binomial heap in c#? [closed]

Answer 1

QuickGraph implements Fibonacci Heaps and Queues in C#, among a whole lot of other stuff. It is free and open-source.

Answer 2

Free C# implementation of heaps and many other data structures:

• The C5 Generic Collection Library for C# and CLI
• Wintellect's Power Collections for .NET

Answer 3

Implementation of MinHeap and MaxHeap:

public abstract class Heap<T>
{
    private List<T> m_Vector;

    private void Swap(int i, int j)
    {
        var tmp = m_Vector[i];
        m_Vector[i] = m_Vector[j];
        m_Vector[j] = tmp;
    }

    protected abstract int Compare(T a, T b);

    private void SiftUp(int i)
    {
        if (i == 0)
        {
            return;
        }

        int parent = (i - 1) / 2;

        if (Compare(m_Vector[i], m_Vector[parent]) >= 0)
        {
            return;
        }

        Swap(i, parent);
        SiftUp(parent);
    }

    private void SiftDown(int i)
    {
        int left = i * 2 + 1;

        if (left >= m_Vector.Count)
        {
            return;
        }

        var right = left + 1;

        var child = left;

        if (right < m_Vector.Count)
        {
            if (Compare(m_Vector[left], m_Vector[right]) > 0)
            {
                child = right;
            }
        }

        if (Compare(m_Vector[i], m_Vector[child]) <= 0)
        {
            return;
        }

        Swap(i, child);
        SiftDown(child);
    }

    public Heap()
    {
        m_Vector = new List<T>();
    }

    public Heap(IEnumerable<T> elements)
    {
        m_Vector = new List<T>(elements);

        if (m_Vector.Count < 2)
        {
            return;
        }

        //
        // From the last parent, upwards, sift down. Each sift is O<1>.
        //
        for (int i = (m_Vector.Count - 2) / 2; i >= 0; i--)
        {
            SiftDown(i);
        }
    }

    public int Count { get { return m_Vector.Count; } }

    public void Add(T element)
    {
        m_Vector.Add(element);
        SiftUp(m_Vector.Count - 1);
    }

    public T Top
    {
        get
        {
            if (m_Vector.Count == 0)
            {
                throw new InvalidOperationException();
            }
            return m_Vector[0];
        }
    }

    public T Fetch()
    {
        if (m_Vector.Count == 0)
        {
            throw new InvalidOperationException();
        }

        T result = m_Vector[0];
        m_Vector[0] = m_Vector[m_Vector.Count - 1];
        m_Vector.RemoveAt(m_Vector.Count - 1);

        SiftDown(0);

        return result;
    }
}

public class MinHeap<T> : Heap<T> where T: IComparable 
{
    protected override int Compare(T a, T b)
    {
        return a.CompareTo(b);
    }

    public MinHeap() : base()
    {
    }

    public MinHeap(IEnumerable<T> elements) : base(elements)
    {
    }
}

public class MaxHeap<T> : Heap<T> where T : IComparable
{
    protected override int Compare(T a, T b)
    {
        return b.CompareTo(a);
    }

    public MaxHeap() : base()
    {
    }

    public MaxHeap(IEnumerable<T> elements) : base(elements)
    {
    }
}

Answer 4

I don't know of any native framework implementation.

I found two implementations of binary heap (link 1, link 2) and one implementation of binomial heap in f# (link).

Answer 5

Stand alone stress tested implementations are in Github under Advanced-Algorithms repository (I own it). DecrementKey operation performance is what makes later two significant.

• Binary Min/Max Heap
• Binomial Min/Max Heap
• Fibornacci Min/Max Heap

The repository has two more heap implementations, D-Ary Heap & Pairing Heap.

Answer 6

I believe that a SortedSet<KeyValuePair<K,V>> with a custom Comparer will do the job.

The Comparer will look like the following:

class KeyValueComparer<K, V> : IComparer<KeyValuePair<K,V>> where K:IComparable where V:IComparable
{
    public int Compare(KeyValuePair<K, V> x, KeyValuePair<K, V> y)
    {
        var res = x.Key.CompareTo(y.Key);
        return res == 0 ? x.Value.CompareTo(y.Value) : res;
    }
}

With such Comparer, the SortedSet will be sorted by Key and it will allow duplicates of keys.

You can get the Min at constant time, RemoveMin at O(logn), Add an entry at O(logn) and Update a key at O(logn).

Here is a full (or almost) implementation:

public class Heap<K, V>
    where K : IComparable
    where V : IComparable
{
    private readonly SortedSet<KeyValuePair<K, V>> _sortedSet;

    // O(1)
    public KeyValuePair<K, V> Min
    {
        get { return _sortedSet.Min; }
    }

    public Heap()
    {
        _sortedSet = new SortedSet<KeyValuePair<K, V>>(new KeyValueComparer<K, V>());
    } 

    // O(logn)
    public void Add(K key, V value)
    {
        _sortedSet.Add(new KeyValuePair<K, V>(key, value));
    }

    // O(logn)
    public KeyValuePair<K, V> RemoveMin()
    {
        var min = Min;
        _sortedSet.Remove(min);
        return min;
    }

    // O(logn)
    public void Remove(K key, V value)
    {
        _sortedSet.Remove(new KeyValuePair<K, V>(key, value));
    }

    // O(logn)
    public void UpdateKey(K oldKey, V oldValue, K newKey)
    {
        Remove(oldKey, oldValue);
        Add(newKey, oldValue);
    }

    private class KeyValueComparer<K, V> : IComparer<KeyValuePair<K, V>>
        where K : IComparable
        where V : IComparable
    {
        public int Compare(KeyValuePair<K, V> x, KeyValuePair<K, V> y)
        {
            var res = x.Key.CompareTo(y.Key);
            return res == 0 ? x.Value.CompareTo(y.Value) : res;
        }
    }
}