C# Academy · Lección

HashSet y unicidad

Realice un seguimiento de valores distintos

HashSet y unicidad es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

¿Qué es HashSet?

HashSet<T> almacena una colección de valores únicos sin duplicados. Agregar un valor que ya está presente simplemente no hace nada.

Al igual que un diccionario, se basa en una tabla hash, por lo que las comprobaciones de pertenencia son O(1) en promedio. No conserva el orden de inserción.

using System.Collections.Generic;

var seen = new HashSet<int>();
seen.Add(1);
seen.Add(1); // ignored, still one element

Add devuelve un valor booleano

Add devuelve true si el valor era nuevo y false si ya estaba presente.

Este valor de retorno resulta útil para detectar duplicados en un solo paso, sin una comprobación independiente con Contains.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var set = new HashSet<string>();
        Console.WriteLine(set.Add("a")); // True
        Console.WriteLine(set.Add("a")); // False
    }
}

Comprobaciones rápidas de pertenencia

Contains en un HashSet es O(1) en promedio, frente a O(n) en una List.

Cuando pregunta repetidamente «¿ya he visto esto?», un conjunto es la herramienta adecuada. La diferencia de velocidad aumenta drásticamente a medida que crece la colección.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var ids = new HashSet<int> { 10, 20, 30 };
        Console.WriteLine(ids.Contains(20)); // True
        Console.WriteLine(ids.Contains(99)); // False
    }
}

Eliminar duplicados de una lista

Una tarea común consiste en tomar una lista y conservar solo los valores distintos. Crear un HashSet a partir de la lista lo hace en O(n).

El conjunto resultante contiene cada valor una sola vez. Si necesita recuperar una lista, envuélvalo así: new List<int>(set).

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var nums = new List<int> { 1, 2, 2, 3, 3, 3 };
        var unique = new HashSet<int>(nums);
        Console.WriteLine(unique.Count); // 3
    }
}

Unión

UnionWith agrega cada elemento de otra colección y omite los duplicados. El resultado contiene todos los elementos de ambas.

Esto modifica el conjunto directamente. Es mucho más limpio que recorrer la otra colección y llamar a Add para cada elemento.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var a = new HashSet<int> { 1, 2, 3 };
        a.UnionWith(new[] { 3, 4, 5 });
        Console.WriteLine(a.Count); // 5
    }
}

Intersección

IntersectWith conserva solo los elementos que también aparecen en la otra colección y elimina el resto.

Utilícelo para encontrar elementos comunes, como etiquetas compartidas por dos artículos o usuarios que pertenecen a dos grupos.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var a = new HashSet<int> { 1, 2, 3, 4 };
        a.IntersectWith(new[] { 2, 4, 6 });
        Console.WriteLine(string.Join(",", a)); // 2,4
    }
}

Diferencia

ExceptWith elimina del conjunto cualquier elemento que se encuentre en la otra colección, dejando los elementos exclusivos del conjunto.

Es la operación de diferencia de conjuntos: «elementos de A, pero no de B». Resulta ideal para calcular qué cambió o qué queda por procesar.

var a = new HashSet<int> { 1, 2, 3, 4 };
a.ExceptWith(new[] { 2, 4 });
// a now contains 1 and 3

Subconjunto y superconjunto

IsSubsetOf y IsSupersetOf comprueban las relaciones de inclusión entre conjuntos y devuelven un bool.

Overlaps comprueba si comparten algún elemento, y SetEquals verifica si dos conjuntos contienen exactamente los mismos elementos, independientemente del orden.

var a = new HashSet<int> { 1, 2 };
var b = new HashSet<int> { 1, 2, 3 };
bool sub = a.IsSubsetOf(b);   // true
bool ov = a.Overlaps(b);      // true

Igualdad de elementos

La unicidad depende de GetHashCode y Equals del tipo de elemento, exactamente igual que en las claves de un diccionario.

Para los tipos personalizados, sobrescriba ambos métodos o utilice un record; de lo contrario, dos objetos lógicamente iguales se tratarán como distintos y ambos acabarán en el conjunto.

var names = new HashSet<string>(
    System.StringComparer.OrdinalIgnoreCase);
names.Add("Sam");
bool dup = !names.Add("SAM"); // true: treated as same

Sin indexación ni orden

Un HashSet no permite acceder por índice; no puede escribir set[0]. Solo puede enumerarlo con foreach.

El orden de enumeración no está garantizado. Si necesita tanto unicidad como ordenación, utilice SortedSet<T>, que mantiene los elementos ordenados a cambio de operaciones con un coste de O(log n).

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var s = new SortedSet<int> { 3, 1, 2 };
        Console.WriteLine(string.Join(",", s)); // 1,2,3
    }
}

Seguimiento de elementos vistos

Un patrón frecuente consiste en filtrar un flujo para que cada valor aparezca una sola vez. Agregue cada valor a un conjunto y actúe solo cuando Add devuelva true.

Esto es más limpio y rápido que comprobar una lista cada vez más grande, ya que convierte un recorrido O(n²) en O(n).

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var seen = new HashSet<int>();
        foreach (int x in new[] { 1, 1, 2, 3, 2 })
            if (seen.Add(x)) Console.Write(x + " ");
        // prints 1 2 3
    }
}

Comprobación rápida

Recuerde qué garantiza un HashSet y cuál es el coste de sus consultas.

Resumen

HashSet<T> almacena valores únicos y ofrece operaciones de agregado, eliminación y comprobación de pertenencia en O(1) en promedio, pero no proporciona orden ni indexación.

Resulta ideal para eliminar duplicados, comprobar rápidamente «¿ya he visto esto?» y realizar operaciones de conjuntos mediante UnionWith, IntersectWith y ExceptWith. Los tipos de elementos personalizados necesitan una igualdad adecuada.

Preguntas frecuentes

¿La lección «HashSet y unicidad» es gratis?

Sí — el texto completo de «HashSet y unicidad» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «HashSet y unicidad»?

Realice un seguimiento de valores distintos Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «HashSet y unicidad»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C# Academy