HashSet <T> rispetto a Dictionary <K, V> rispetto al tempo di ricerca per trovare se un elemento esiste

HashSet<T> t = new HashSet<T>();
// add 10 million items


Dictionary<K, V> t = new Dictionary<K, V>();
// add 10 million items.

Quale .Containsmetodo tornerà più rapidamente?

Giusto per chiarire, il mio requisito è che ho 10 milioni di oggetti (beh, davvero le stringhe) che devo controllare se esistono nella struttura dei dati. Non itererò MAI.

HashSet vs List vs Dictionary performance test, preso da qui .

Aggiungi 1000000 oggetti (senza controllare i duplicati)

Contiene il controllo per metà degli oggetti di una raccolta di 10000

Rimuovi metà degli oggetti di una collezione di 10.000

Presumo che intendi Dictionary<TKey, TValue>nel secondo caso? HashTableè una classe non generica.

Dovresti scegliere la collezione giusta per il lavoro in base alle tue effettive esigenze. Si fa realmente desidera mappare ogni chiave ad un valore? Se è così, usa Dictionary<,>. Se ti interessa solo come set, usa HashSet<>.

Mi aspetto che HashSet<T>.Containse Dictionary<TKey, TValue>.ContainsKey(che sono le operazioni comparabili, supponendo che tu stia usando il tuo dizionario in modo sensato) fondamentalmente eseguano lo stesso - stanno usando lo stesso algoritmo, fondamentalmente. Immagino che con le voci Dictionary<,>più grandi si finisce con una maggiore probabilità di saltare la cache con Dictionary<,>che con HashSet<>, ma mi aspetto che sia insignificante rispetto al dolore di scegliere il tipo di dati sbagliato semplicemente in termini di ciò che stai cercando di raggiungere.

Dalla documentazione MSDN per Dictionary <TKey, TValue>

"Recuperare un valore utilizzando la sua chiave è molto veloce, vicino a O (1) , perché la classe Dictionary è implementata come una tabella hash. "

Con una nota:

"La velocità di recupero dipende dalla qualità dell'algoritmo di hashing del tipo specificato per TKey"

So che la tua domanda / post è vecchia, ma mentre cercavo una risposta a una domanda simile mi sono imbattuto in questo.

Spero che questo ti aiuti. Scorri verso il basso fino alla sezione Osservazioni per maggiori dettagli. https://msdn.microsoft.com/en-us/library/xfhwa508(v=vs.110).aspx

Queste sono diverse strutture di dati. Inoltre non esiste una versione generica di HashTable.

HashSetcontiene valori di tipo T che HashTable(o Dictionary) contiene coppie chiave-valore. Quindi dovresti scegliere la raccolta su quali dati devi archiviare.

La risposta accettata a questa domanda NON risponde validamente alla domanda! Capita di dare la risposta corretta, ma quella risposta non è mostrata dalle prove che hanno fornito.

Ciò che mostra la risposta è che le ricerche di chiavi su a Dictionaryo HashSetsono molto più veloci di quelle in a List. Il che è vero, ma non interessante, né sorprendente, né prova che abbiano la stessa velocità.

Ho eseguito il codice seguente per confrontare i tempi di ricerca e la mia conclusione è che in realtà sono la stessa velocità. (O almeno, se c'è qualche differenza, allora la differenza è ben all'interno della deviazione standard di quella velocità)

In particolare, per me, in questo test, 100.000.000 di ricerche hanno richiesto tra 10 e 11,5 secondi per entrambi.

Codice di prova:

private const int TestReps = 100_000_000;
[Test]
public void CompareHashSetContainsVersusDictionaryContainsKey()
{
    for (int j = 0; j < 10; j++)
    {
        var rand = new Random();
        var dict = new Dictionary<int, int>();
        var hash = new HashSet<int>();

        for (int i = 0; i < TestReps; i++)
        {
            var key = rand.Next();
            var value = rand.Next();
            hash.Add(key);
            dict.TryAdd(key, value);
        }

        var testPoints = Enumerable.Repeat(1, TestReps).Select(_ => rand.Next()).ToArray();
        var timer = new Stopwatch();
        var total = 0;
        
        timer.Restart();
            for (int i = 0; i < TestReps; i++)
            {
                var newKey = testPoints[i];
                if (hash.Contains(newKey))
                {
                    total++;
                }
            }
        Console.WriteLine(timer.Elapsed);
        
        var target = total;
        Assert.That(total == target);
        

        timer.Restart();
            for (int i = 0; i < TestReps; i++)
            {
                var newKey = testPoints[i];
                if (dict.ContainsKey(newKey))
                {
                    total++;
                }
            }
        Console.WriteLine(timer.Elapsed);

        Assert.That(total == target * 2);
        Console.WriteLine("Set");
    }
}