web-dev-qa-db-ja.com

.NETのヒープクラス

可能性のある複製：
c＃のフィボナッチ、バイナリ、または二項ヒープ？

.NETにヒープのようなクラスはありますか？いくつかの種類のコレクションが必要ですが、そこから最小値を取得できます。素子。私は3つの方法が欲しいだけです：

  • 追加（）
  • RemoveMinElement（）
  • GetMinElement（）

キーは一意でなければならないため、並べ替えられたリストを使用できません。同じ要素が複数ある場合があります。

c#.netheap
19
Tomek Tarczynski

カスタムキーで SortedList または SortedDictionary （以下の説明を参照）を使用できます。参照等価性を持つ型を使用したが、気になる値に基づいて比較できる場合、これは機能する可能性があります。

このようなもの：

class HeapKey : IComparable<HeapKey>
{
    public HeapKey(Guid id, Int32 value)
    {
        Id = id;
        Value = value;
    }

    public Guid Id { get; private set; }
    public Int32 Value { get; private set; }

    public int CompareTo(HeapKey other)
    {
        if (_enableCompareCount)
        {
            ++_compareCount;
        }

        if (other == null)
        {
            throw new ArgumentNullException("other");
        }

        var result = Value.CompareTo(other.Value);

        return result == 0 ? Id.CompareTo(other.Id) : result;
    }
}

バイナリヒープのパフォーマンス特性を持つSortedDictionaryの使用例を次に示します。

using System;
using System.Collections.Generic;
using System.Linq;

namespace SortedDictionaryAsBinaryHeap
{
    class Program
    {
        private static Boolean _enableCompareCount = false;
        private static Int32 _compareCount = 0;

        static void Main(string[] args)
        {
            var rnd = new Random();

            for (int elementCount = 2; elementCount <= 6; elementCount++)
            {
                var keyValues = Enumerable.Range(0, (Int32)Math.Pow(10, elementCount))
                    .Select(i => new HeapKey(Guid.NewGuid(), rnd.Next(0, 10)))
                    .ToDictionary(k => k);
                var heap = new SortedDictionary<HeapKey, HeapKey>(keyValues);

                _compareCount = 0;
                _enableCompareCount = true;
                var min = heap.First().Key;
                _enableCompareCount = false;
                Console.WriteLine("Element count: {0}; Compare count for getMinElement: {1}",
                                  (Int32)Math.Pow(10, elementCount),
                                  _compareCount);   

                _compareCount = 0;
                _enableCompareCount = true;
                heap.Remove(min);
                _enableCompareCount = false;
                Console.WriteLine("Element count: {0}; Compare count for deleteMinElement: {1}", 
                                  (Int32)Math.Pow(10, elementCount),  
                                  _compareCount);   
            }

            Console.ReadKey();
        }

        private class HeapKey : IComparable<HeapKey>
        {
            public HeapKey(Guid id, Int32 value)
            {
                Id = id;
                Value = value;
            }

            public Guid Id { get; private set; }
            public Int32 Value { get; private set; }

            public int CompareTo(HeapKey other)
            {
                if (_enableCompareCount)
                {
                    ++_compareCount;
                }

                if (other == null)
                {
                    throw new ArgumentNullException("other");
                }

                var result = Value.CompareTo(other.Value);

                return result == 0 ? Id.CompareTo(other.Id) : result;
            }
        }
    }
}

結果：

要素数：100; getMinElementのカウントを比較する：0

要素数：100; deleteMinElementのカウントを比較：8

要素数：1000; getMinElementのカウントを比較する：0

要素数：1000; deleteMinElementのカウントを比較する：10

要素数：10000; getMinElementのカウントを比較する：0

要素数：10000; deleteMinElementのカウントの比較：13

要素数：100000; getMinElementのカウントを比較する：0

要素数：100000; deleteMinElementのカウントを比較：14

要素数：1000000; getMinElementのカウントを比較する：0

要素数：1000000; deleteMinElementのカウントを比較：21

10
codekaizen

プライオリティキューは問題に適しているように見えます。 。Netのプライオリティキュー

その他の実装については、「C＃優先キュー」のGoogle。

2
Ed Power