HashSet <T> versus Dictionary <K, V> wrt tiempo de búsqueda para encontrar si existe un elemento

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


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

¿ .ContainsQué método volverá más rápido?

Solo para aclarar, mi requisito es tener 10 millones de objetos (bueno, cadenas en realidad) que necesito verificar si existen en la estructura de datos. NUNCA iteraré.

Prueba de rendimiento HashSet vs List vs Dictionary, tomada de aquí .

Agregue 1000000 objetos (sin verificar los duplicados)

Contiene cheque por la mitad de los objetos de una colección de 10000

Elimina la mitad de los objetos de una colección de 10000

¿Supongo que te refieres Dictionary<TKey, TValue>al segundo caso? HashTablees una clase no genérica.

Debe elegir la colección adecuada para el trabajo según sus requisitos reales. ¿Realmente desea asignar cada clave a un valor? Si es así, utilice Dictionary<,>. Si solo te importa como conjunto, úsalo HashSet<>.

Yo esperaría que HashSet<T>.Containsy Dictionary<TKey, TValue>.ContainsKey(que son las operaciones comparables, asumiendo que está usando su diccionario con sensatez) para realizar básicamente lo mismo: están usando el mismo algoritmo, fundamentalmente. Supongo que con las entradas Dictionary<,>más grandes terminas con una mayor probabilidad de volar el caché con Dictionary<,>que con HashSet<>, pero esperaría que eso sea insignificante en comparación con el dolor de elegir el tipo de datos incorrecto simplemente en términos de lo que estás tratando de lograr.

De la documentación de MSDN para Dictionary <TKey, TValue>

"Recuperar un valor usando su clave es muy rápido, cercano a O (1) , porque la clase Dictionary se implementa como una tabla hash " .

Con una nota:

"La velocidad de recuperación depende de la calidad del algoritmo de hash del tipo especificado para TKey"

Sé que su pregunta / publicación es antigua, pero mientras buscaba una respuesta a una pregunta similar me encontré con esto.

Espero que esto ayude. Desplácese hacia abajo hasta la sección Comentarios para obtener más detalles. https://msdn.microsoft.com/en-us/library/xfhwa508(v=vs.110).aspx

Estas son diferentes estructuras de datos. Además, no existe una versión genérica deHashTable .

HashSetcontiene valores de tipo T que HashTable(o Dictionary) contiene pares clave-valor. Por lo tanto, debe elegir la recopilación de los datos que necesita almacenar.

¡La respuesta aceptada a esta pregunta NO responde válidamente a la pregunta! Da la respuesta correcta, pero esa respuesta no se muestra en la evidencia que proporcionaron.

Lo que muestra esa respuesta es que las búsquedas clave en un Dictionaryo HashSetson mucho más rápidas que buscar en un List. Lo cual es cierto, pero no interesante, ni sorprendente, ni prueba de que tengan el mismo velocidad.

Ejecuté el siguiente código para comparar los tiempos de búsqueda y mi conclusión es que, de hecho, SON a la misma velocidad. (O al menos, si hay alguna diferencia, entonces la diferencia está dentro de la desviación estándar de esa velocidad)

Específicamente, 100.000.000 de búsquedas tardaron entre 10 y 11,5 segundos para ambos, para mí, en esta prueba.

Código de prueba:

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");
    }
}