HashSet<T> básico

Un HashSet<T> es una colección de elementos únicos en C# que implementa la interfaz ISet<T>. A diferencia de las listas, un HashSet no mantiene un orden específico de elementos y no permite duplicados, lo que lo convierte en una estructura de datos eficiente para operaciones como búsqueda, inserción y eliminación.

Características principales

El HashSet se caracteriza por:

• Unicidad de elementos: No permite duplicados
• Rendimiento optimizado: Operaciones de búsqueda en tiempo constante O(1)
• Sin orden específico: No garantiza el orden de los elementos
• Implementación basada en tablas hash: Utiliza funciones hash para almacenar elementos

Creación de un HashSet

Crear un HashSet es sencillo y similar a otras colecciones en C#:

// HashSet vacío de enteros
HashSet<int> numeros = new HashSet<int>();

// HashSet inicializado con valores
HashSet<string> frutas = new HashSet<string> { "manzana", "naranja", "plátano" };

// HashSet a partir de una colección existente
List<double> listaValores = new List<double> { 1.5, 2.7, 3.8, 1.5 };
HashSet<double> valoresUnicos = new HashSet<double>(listaValores);
// valoresUnicos contendrá: 1.5, 2.7, 3.8 (sin duplicados)

Operaciones básicas

El HashSet proporciona métodos intuitivos para manipular la colección:

Añadir elementos

HashSet<string> lenguajes = new HashSet<string>();

// Añadir elementos individuales
lenguajes.Add("C#");
lenguajes.Add("Python");

// Si intentamos añadir un elemento duplicado, Add devuelve false
bool fueAgregado = lenguajes.Add("C#"); // fueAgregado será false

Comprobar existencia

La comprobación de existencia es extremadamente rápida en un HashSet:

HashSet<int> codigos = new HashSet<int> { 101, 202, 303 };

// Verificar si un elemento existe
bool existe = codigos.Contains(202); // true
bool noExiste = codigos.Contains(404); // false

Eliminar elementos

HashSet<char> caracteres = new HashSet<char> { 'a', 'b', 'c', 'd' };

// Eliminar un elemento específico
caracteres.Remove('b'); // Ahora contiene: 'a', 'c', 'd'

// Eliminar todos los elementos
caracteres.Clear(); // HashSet vacío

Recorrido de elementos

Aunque un HashSet no tiene índices como una lista, podemos recorrerlo fácilmente:

HashSet<string> ciudades = new HashSet<string> { "Madrid", "Barcelona", "Valencia" };

// Usando foreach
foreach (string ciudad in ciudades)
{
    Console.WriteLine(ciudad);
}

// Usando LINQ
var ciudadesConM = ciudades.Where(c => c.StartsWith("M"));

Propiedades útiles

El HashSet incluye propiedades que facilitan su uso:

HashSet<int> numeros = new HashSet<int> { 10, 20, 30 };

// Obtener el número de elementos
int cantidad = numeros.Count; // 3

// Verificar si está vacío
bool estaVacio = numeros.Count == 0; // false

Comparación con List<T>

Es importante entender cuándo usar un HashSet en lugar de una List:

Ejemplo práctico

Veamos un ejemplo que muestra la ventaja de usar HashSet para filtrar valores únicos:

// Supongamos que tenemos una lista de IDs de usuarios que han visitado una página
List<int> visitantes = new List<int> { 101, 203, 101, 305, 203, 407, 101 };

// Usando List para obtener valores únicos (enfoque ineficiente)
List<int> visitantesUnicosConLista = new List<int>();
foreach (int id in visitantes)
{
    if (!visitantesUnicosConLista.Contains(id)) // Operación O(n)
    {
        visitantesUnicosConLista.Add(id);
    }
}

// Usando HashSet (enfoque eficiente)
HashSet<int> visitantesUnicos = new HashSet<int>(visitantes);

Console.WriteLine($"Visitantes totales: {visitantes.Count}"); // 7
Console.WriteLine($"Visitantes únicos: {visitantesUnicos.Count}"); // 4

Consideraciones de rendimiento

El HashSet es ideal cuando:

• Necesitas verificar rápidamente si un elemento existe
• Quieres eliminar duplicados de una colección
• No te importa el orden de los elementos
• Realizas muchas operaciones de inserción y eliminación

Sin embargo, si necesitas mantener un orden específico o acceder a elementos por índice, una List o un SortedSet podrían ser más apropiados.

Eliminación de duplicados

Una de las aplicaciones más prácticas y comunes de HashSet es la eliminación de elementos duplicados de una colección. Gracias a su característica inherente de almacenar solo valores únicos, HashSet se convierte en la herramienta ideal para este propósito, ofreciendo un rendimiento superior a otros enfoques.

Eliminación de duplicados básica

La forma más sencilla de eliminar duplicados es crear un HashSet a partir de la colección original:

// Lista con elementos duplicados
List<string> palabras = new List<string> { 
    "hola", "mundo", "hola", "programación", "mundo", "c#" 
};

// Convertir a HashSet para eliminar duplicados
HashSet<string> palabrasUnicas = new HashSet<string>(palabras);

// Resultado: "hola", "mundo", "programación", "c#"
foreach (string palabra in palabrasUnicas)
{
    Console.WriteLine(palabra);
}

Este enfoque es significativamente más eficiente que los métodos tradicionales que utilizan bucles anidados o múltiples comprobaciones.

Comparación de rendimiento

Para entender mejor la ventaja de usar HashSet, comparemos el rendimiento con un enfoque basado en List:

// Método ineficiente usando List
public static List<T> EliminarDuplicadosConList<T>(List<T> lista)
{
    List<T> resultado = new List<T>();
    
    foreach (T item in lista)
    {
        if (!resultado.Contains(item)) // Operación O(n)
        {
            resultado.Add(item);
        }
    }
    
    return resultado;
}

// Método eficiente usando HashSet
public static List<T> EliminarDuplicadosConHashSet<T>(List<T> lista)
{
    // Conversión a HashSet y de vuelta a List
    return new HashSet<T>(lista).ToList();
}

Con colecciones grandes, la diferencia de rendimiento es notable:

• El método con List tiene complejidad O(n²) porque Contains() es O(n)
• El método con HashSet tiene complejidad O(n) porque las operaciones de HashSet son O(1)

Preservando el orden original

Un inconveniente de HashSet es que no mantiene el orden original de los elementos. Si necesitas eliminar duplicados pero conservar el orden de aparición, puedes combinar HashSet con List:

public static List<T> EliminarDuplicadosPreservandoOrden<T>(List<T> lista)
{
    HashSet<T> yaVistos = new HashSet<T>();
    List<T> resultado = new List<T>();
    
    foreach (T item in lista)
    {
        if (yaVistos.Add(item)) // Add devuelve true si el elemento no existía
        {
            resultado.Add(item);
        }
    }
    
    return resultado;
}

Este método aprovecha el rendimiento de HashSet para las comprobaciones mientras mantiene el orden original en la lista resultante.

Aplicaciones prácticas

La eliminación de duplicados es útil en muchos escenarios reales:

• Procesamiento de datos: Limpiar registros duplicados de archivos CSV o bases de datos

// Ejemplo: Filtrar IDs de usuarios únicos de un registro
List<int> todosLosRegistros = ObtenerRegistrosDeUsuario();
HashSet<int> idsUnicos = new HashSet<int>(todosLosRegistros);
Console.WriteLine($"Registros totales: {todosLosRegistros.Count}");
Console.WriteLine($"Usuarios únicos: {idsUnicos.Count}");

• Análisis de texto: Contar palabras únicas en un documento

string texto = "Este es un ejemplo de texto. Este texto contiene palabras repetidas.";
string[] palabras = texto.Split(new[] { ' ', '.', ',', ';', ':', '!', '?' }, 
                               StringSplitOptions.RemoveEmptyEntries);
                               
HashSet<string> palabrasUnicas = new HashSet<string>(
    palabras, StringComparer.OrdinalIgnoreCase); // Ignora mayúsculas/minúsculas
    
Console.WriteLine($"Palabras totales: {palabras.Length}"); // 12
Console.WriteLine($"Palabras únicas: {palabrasUnicas.Count}"); // 9

• Filtrado de resultados: Eliminar resultados duplicados en búsquedas

// Resultados de búsqueda de múltiples fuentes que pueden contener duplicados
List<Producto> resultadosFuente1 = BuscarProductos("smartphone");
List<Producto> resultadosFuente2 = BuscarProductosRelacionados("smartphone");

// Combinar y eliminar duplicados basados en el ID del producto
HashSet<Producto> resultadosUnicos = new HashSet<Producto>(
    resultadosFuente1.Concat(resultadosFuente2),
    new ProductoComparer() // Implementación de IEqualityComparer<Producto>
);

Trabajando con tipos complejos

Para eliminar duplicados de objetos personalizados, necesitas implementar correctamente Equals y GetHashCode, o proporcionar un IEqualityComparer<T>:

public class Persona
{
    public string Nombre { get; set; }
    public string Email { get; set; }
    
    // Sobrescribir Equals para comparar por Email
    public override bool Equals(object obj)
    {
        if (obj is Persona otra)
        {
            return Email.Equals(otra.Email, StringComparison.OrdinalIgnoreCase);
        }
        return false;
    }
    
    // Sobrescribir GetHashCode para generar hash basado en Email
    public override int GetHashCode()
    {
        return Email.ToLowerInvariant().GetHashCode();
    }
}

// Uso
List<Persona> listaPersonas = ObtenerPersonas();
HashSet<Persona> personasUnicas = new HashSet<Persona>(listaPersonas);
// Eliminará duplicados basados en el Email

Alternativamente, puedes usar un comparador personalizado:

public class PersonaComparer : IEqualityComparer<Persona>
{
    public bool Equals(Persona x, Persona y)
    {
        return x.Email.Equals(y.Email, StringComparison.OrdinalIgnoreCase);
    }
    
    public int GetHashCode(Persona obj)
    {
        return obj.Email.ToLowerInvariant().GetHashCode();
    }
}

// Uso con comparador personalizado
HashSet<Persona> personasUnicas = new HashSet<Persona>(
    listaPersonas, 
    new PersonaComparer()
);

Integración con LINQ

LINQ proporciona el método Distinct() que internamente utiliza un HashSet para eliminar duplicados:

// Eliminar duplicados con LINQ
List<int> numeros = new List<int> { 1, 2, 3, 1, 2, 4, 5, 3 };
IEnumerable<int> numerosUnicos = numeros.Distinct();
// Resultado: 1, 2, 3, 4, 5

// Con tipos complejos, podemos usar un comparador personalizado
IEnumerable<Persona> personasUnicas = listaPersonas.Distinct(new PersonaComparer());

El método Distinct() ofrece una sintaxis más concisa, pero crear directamente un HashSet puede ser más eficiente cuando necesitas realizar operaciones adicionales sobre la colección de elementos únicos.

Operaciones de conjuntos

Una de las ventajas principales de utilizar HashSet en C# es la capacidad de realizar operaciones matemáticas de conjuntos de manera eficiente. Estas operaciones nos permiten combinar, comparar y manipular colecciones de elementos de formas que serían mucho más complejas de implementar manualmente con otras estructuras de datos.

Operaciones fundamentales

HashSet implementa la interfaz ISet<T> que proporciona métodos específicos para realizar operaciones de teoría de conjuntos:

• Unión: Combina elementos de dos conjuntos
• Intersección: Obtiene elementos comunes entre conjuntos
• Diferencia: Obtiene elementos que están en un conjunto pero no en otro
• Subconjunto/Superconjunto: Verifica relaciones de inclusión entre conjuntos

Veamos cada una de estas operaciones con ejemplos prácticos.

Unión de conjuntos

La unión combina todos los elementos de dos conjuntos, eliminando duplicados automáticamente:

HashSet<int> conjunto1 = new HashSet<int> { 1, 2, 3, 4 };
HashSet<int> conjunto2 = new HashSet<int> { 3, 4, 5, 6 };

// Método 1: UnionWith modifica el conjunto original
conjunto1.UnionWith(conjunto2);
// conjunto1 ahora contiene: 1, 2, 3, 4, 5, 6

// Método 2: Crear un nuevo conjunto con la unión
HashSet<int> conjunto3 = new HashSet<int> { 1, 2, 3, 4 };
HashSet<int> conjunto4 = new HashSet<int> { 3, 4, 5, 6 };
HashSet<int> union = new HashSet<int>(conjunto3);
union.UnionWith(conjunto4);
// union contiene: 1, 2, 3, 4, 5, 6

La operación de unión es útil cuando necesitamos combinar datos de múltiples fuentes sin preocuparnos por duplicados:

// Ejemplo: Combinar listas de correos electrónicos de diferentes departamentos
HashSet<string> correosMarketing = new HashSet<string>(ObtenerCorreosMarketing());
HashSet<string> correosVentas = new HashSet<string>(ObtenerCorreosVentas());

// Obtener lista completa sin duplicados
correosMarketing.UnionWith(correosVentas);
List<string> todosLosCorreos = correosMarketing.ToList();

Intersección de conjuntos

La intersección obtiene solo los elementos que existen en ambos conjuntos:

HashSet<string> tecnologiasEquipo1 = new HashSet<string> { "C#", "SQL", "HTML", "CSS" };
HashSet<string> tecnologiasEquipo2 = new HashSet<string> { "JavaScript", "HTML", "CSS", "Python" };

// IntersectWith modifica el conjunto original
tecnologiasEquipo1.IntersectWith(tecnologiasEquipo2);
// tecnologiasEquipo1 ahora contiene: "HTML", "CSS"

// Para preservar los conjuntos originales, crear una copia
HashSet<string> tecnologiasComunes = new HashSet<string>(tecnologiasEquipo1);
tecnologiasComunes.IntersectWith(tecnologiasEquipo2);

La intersección es especialmente útil para encontrar elementos comunes entre colecciones:

// Ejemplo: Encontrar clientes que compraron en ambos períodos
HashSet<int> clientesPrimerTrimestre = new HashSet<int>(ObtenerClientesPrimerTrimestre());
HashSet<int> clientesSegundoTrimestre = new HashSet<int>(ObtenerClientesSegundoTrimestre());

clientesPrimerTrimestre.IntersectWith(clientesSegundoTrimestre);
Console.WriteLine($"Clientes que compraron en ambos trimestres: {clientesPrimerTrimestre.Count}");

Diferencia de conjuntos

La diferencia obtiene elementos que están en el primer conjunto pero no en el segundo:

HashSet<char> grupo1 = new HashSet<char> { 'a', 'b', 'c', 'd' };
HashSet<char> grupo2 = new HashSet<char> { 'c', 'd', 'e', 'f' };

// ExceptWith modifica el conjunto original
grupo1.ExceptWith(grupo2);
// grupo1 ahora contiene: 'a', 'b'

// Para preservar los conjuntos originales
HashSet<char> diferencia = new HashSet<char>(grupo1);
diferencia.ExceptWith(grupo2);

Esta operación es útil para identificar elementos exclusivos:

// Ejemplo: Encontrar productos que están en el catálogo pero no en stock
HashSet<int> productosCatalogo = new HashSet<int>(ObtenerIdProductosCatalogo());
HashSet<int> productosEnStock = new HashSet<int>(ObtenerIdProductosEnStock());

productosCatalogo.ExceptWith(productosEnStock);
// productosCatalogo ahora contiene solo IDs de productos sin stock

Diferencia simétrica

La diferencia simétrica obtiene elementos que están en cualquiera de los conjuntos, pero no en ambos:

HashSet<int> numeros1 = new HashSet<int> { 1, 2, 3, 4 };
HashSet<int> numeros2 = new HashSet<int> { 3, 4, 5, 6 };

// SymmetricExceptWith modifica el conjunto original
numeros1.SymmetricExceptWith(numeros2);
// numeros1 ahora contiene: 1, 2, 5, 6

Esta operación es útil para encontrar elementos exclusivos de cada conjunto:

// Ejemplo: Encontrar habilidades únicas entre dos equipos
HashSet<string> habilidadesEquipo1 = new HashSet<string> { "C#", "SQL", "Azure", "React" };
HashSet<string> habilidadesEquipo2 = new HashSet<string> { "Java", "SQL", "AWS", "React" };

HashSet<string> habilidadesUnicas = new HashSet<string>(habilidadesEquipo1);
habilidadesUnicas.SymmetricExceptWith(habilidadesEquipo2);
// Contiene: "C#", "Azure", "Java", "AWS"

Verificación de relaciones entre conjuntos

HashSet proporciona métodos para verificar relaciones entre conjuntos:

HashSet<string> lenguajesProgramacion = new HashSet<string> { "C#", "Java", "Python", "JavaScript" };
HashSet<string> lenguajesMicrosoft = new HashSet<string> { "C#", "F#", "TypeScript" };
HashSet<string> lenguajesWeb = new HashSet<string> { "JavaScript", "TypeScript", "HTML", "CSS" };

// Verificar si hay elementos comunes
bool tienenComun = lenguajesProgramacion.Overlaps(lenguajesMicrosoft); // true

// Verificar si un conjunto es subconjunto de otro
bool esSubconjunto = lenguajesMicrosoft.IsSubsetOf(lenguajesProgramacion); // false

// Verificar si un conjunto es superconjunto de otro
bool esSuperconjunto = lenguajesProgramacion.IsSupersetOf(lenguajesMicrosoft); // false

// Verificar si los conjuntos son disjuntos (sin elementos comunes)
bool sonDisjuntos = lenguajesMicrosoft.IsProperSubsetOf(lenguajesWeb); // false

Estas verificaciones son útiles para validar relaciones entre colecciones:

// Ejemplo: Verificar si un usuario tiene todos los permisos necesarios
HashSet<string> permisosNecesarios = new HashSet<string> { "leer", "escribir", "eliminar" };
HashSet<string> permisosUsuario = new HashSet<string>(ObtenerPermisosUsuario());

if (permisosUsuario.IsSupersetOf(permisosNecesarios))
{
    Console.WriteLine("El usuario tiene todos los permisos necesarios");
}
else
{
    // Encontrar permisos faltantes
    HashSet<string> permisosFaltantes = new HashSet<string>(permisosNecesarios);
    permisosFaltantes.ExceptWith(permisosUsuario);
    
    Console.WriteLine("Permisos faltantes: " + string.Join(", ", permisosFaltantes));
}

Ejemplo práctico: Sistema de etiquetas

Veamos un ejemplo práctico de cómo las operaciones de conjuntos pueden ser útiles en un sistema de etiquetas para artículos:

// Clase para representar un artículo con etiquetas
public class Articulo
{
    public int Id { get; set; }
    public string Titulo { get; set; }
    public HashSet<string> Etiquetas { get; set; }
    
    public Articulo(int id, string titulo, IEnumerable<string> etiquetas)
    {
        Id = id;
        Titulo = titulo;
        Etiquetas = new HashSet<string>(etiquetas, StringComparer.OrdinalIgnoreCase);
    }
}

// Búsqueda de artículos que contengan TODAS las etiquetas especificadas
public List<Articulo> BuscarArticulosConTodasLasEtiquetas(List<Articulo> articulos, HashSet<string> etiquetasBuscadas)
{
    return articulos.Where(a => a.Etiquetas.IsSupersetOf(etiquetasBuscadas)).ToList();
}

// Búsqueda de artículos que contengan ALGUNA de las etiquetas especificadas
public List<Articulo> BuscarArticulosConAlgunaEtiqueta(List<Articulo> articulos, HashSet<string> etiquetasBuscadas)
{
    return articulos.Where(a => a.Etiquetas.Overlaps(etiquetasBuscadas)).ToList();
}

// Encontrar etiquetas relacionadas (que aparecen junto con una etiqueta específica)
public HashSet<string> EncontrarEtiquetasRelacionadas(List<Articulo> articulos, string etiqueta)
{
    HashSet<string> etiquetasRelacionadas = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
    
    foreach (var articulo in articulos)
    {
        if (articulo.Etiquetas.Contains(etiqueta))
        {
            // Añadir todas las etiquetas excepto la buscada
            foreach (var e in articulo.Etiquetas)
            {
                if (!e.Equals(etiqueta, StringComparison.OrdinalIgnoreCase))
                {
                    etiquetasRelacionadas.Add(e);
                }
            }
        }
    }
    
    return etiquetasRelacionadas;
}

Rendimiento de las operaciones

Las operaciones de conjuntos en HashSet son altamente eficientes comparadas con implementaciones manuales usando listas:

Esta eficiencia se debe a que HashSet utiliza tablas hash internamente, permitiendo operaciones de búsqueda en tiempo constante O(1).

Consideraciones al usar operaciones de conjuntos

• Los métodos como UnionWith, IntersectWith y ExceptWith modifican el conjunto original. Si necesitas preservar los conjuntos originales, crea copias antes de realizar las operaciones.

• Para tipos personalizados, asegúrate de implementar correctamente Equals y GetHashCode o proporcionar un IEqualityComparer<T> para garantizar que las operaciones de conjunto funcionen correctamente.

• Las operaciones de conjuntos son especialmente útiles cuando trabajas con grandes volúmenes de datos donde la eficiencia es crucial.

• Considera usar LINQ como alternativa para operaciones de conjuntos cuando prefieras una sintaxis más declarativa:

// Unión con LINQ
var union = conjunto1.Union(conjunto2);

// Intersección con LINQ
var interseccion = conjunto1.Intersect(conjunto2);

// Diferencia con LINQ
var diferencia = conjunto1.Except(conjunto2);

Sin embargo, ten en cuenta que los métodos de HashSet suelen ser más eficientes que sus equivalentes LINQ cuando trabajas directamente con conjuntos.