Conjuntos em C#

Os conjuntos (ou HashSet) em C# são uma estrutura de dados poderosa, especialmente quando você precisa armazenar elementos únicos e realizar operações de união, interseção e diferença de forma eficiente. Se você já precisou de uma coleção sem elementos duplicados, o HashSet pode ser a solução ideal.

O que é um conjunto (HashSet)?

Em C#, o HashSet é uma implementação da interface ISet, que representa uma coleção de valores únicos, ou seja, não permite duplicatas. Além disso, ele oferece operações de conjuntos, como união, interseção, diferença e subconjunto.

Ele pertence ao namespace System.Collections.Generic e utiliza uma tabela de dispersão (hash table) internamente, o que permite que as operações comuns, como adicionar, remover e buscar elementos, tenham um desempenho rápido, geralmente O(1).

Quando usar um HashSet?

O HashSet é útil em cenários onde:

• Você precisa garantir que não haverá elementos duplicados;
  
  
• Precisa de operações eficientes de adição, remoção e verificação de existência;
  
  
• Realizar operações de conjunto, como união ou interseção entre coleções.

Criando e utilizando um HashSet

Vamos começar com um exemplo básico de como criar e usar um HashSet em C#:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Criando um HashSet de inteiros
        HashSet<int> numeros = new HashSet<int>();

        // Adicionando elementos
        numeros.Add(1);
        numeros.Add(2);
        numeros.Add(3);

        // Tentando adicionar um valor duplicado
        bool adicionou = numeros.Add(3); // Retorna false, pois 3 já está presente
        Console.WriteLine("Adicionou o 3? " + adicionou); // Output: false

        // Exibindo os elementos
        Console.WriteLine("Elementos no HashSet:");
        foreach (int numero in numeros)
        {
            Console.WriteLine(numero);
        }
    }
}

Saída:

Adicionou o 3? False
Elementos no HashSet:
1
2
3

Principais operações com HashSet

O HashSet oferece diversos métodos úteis para trabalhar com coleções de dados de forma eficiente. Vamos ver algumas das operações mais comuns.

União

A união de dois conjuntos combina todos os elementos de ambos os conjuntos, excluindo duplicatas:

HashSet<int> conjuntoA = new HashSet<int> { 1, 2, 3 };
HashSet<int> conjuntoB = new HashSet<int> { 3, 4, 5 };

// União de A e B
conjuntoA.UnionWith(conjuntoB);

Console.WriteLine("União: ");
foreach (int item in conjuntoA)
{
    Console.WriteLine(item); // Saída: 1, 2, 3, 4, 5
}

Interseção

A interseção retorna apenas os elementos que estão presentes em ambos os conjuntos:

HashSet<int> conjuntoA = new HashSet<int> { 1, 2, 3 };
HashSet<int> conjuntoB = new HashSet<int> { 3, 4, 5 };

// Interseção de A e B
conjuntoA.IntersectWith(conjuntoB);

Console.WriteLine("Interseção: ");
foreach (int item in conjuntoA)
{
    Console.WriteLine(item); // Saída: 3
}

Diferença

A diferença retorna os elementos que estão presentes no primeiro conjunto, mas não no segundo:

HashSet<int> conjuntoA = new HashSet<int> { 1, 2, 3 };
HashSet<int> conjuntoB = new HashSet<int> { 3, 4, 5 };

// Diferença de A e B (elementos que estão em A mas não em B)
conjuntoA.ExceptWith(conjuntoB);

Console.WriteLine("Diferença: ");
foreach (int item in conjuntoA)
{
    Console.WriteLine(item); // Saída: 1, 2
}

Subconjuntos

Você pode verificar se um conjunto é subconjunto de outro:

HashSet<int> conjuntoA = new HashSet<int> { 1, 2 };
HashSet<int> conjuntoB = new HashSet<int> { 1, 2, 3 };

bool isSubconjunto = conjuntoA.IsSubsetOf(conjuntoB); // True
Console.WriteLine("A é subconjunto de B? " + isSubconjunto);

Vantagens do HashSet

1. Desempenho: As operações de inserção, remoção e busca em um HashSet são extremamente rápidas, geralmente realizadas em tempo constante (O(1)), graças ao uso de hashing;
   
   
2. Sem duplicatas: O HashSet automaticamente impede a inserção de duplicatas, garantindo que todos os elementos sejam únicos;
   
   
3. Operações de conjunto: Suporte nativo para operações como união, interseção e diferença, facilitando o trabalho com coleções.

Quando não usar um HashSet

Embora o HashSet tenha muitas vantagens, existem situações onde ele não é a melhor escolha:

• Ordem de elementos: O HashSet não mantém a ordem de inserção. Se a ordem dos elementos for importante, considere usar uma List ou SortedSet;
  
  
• Chaves únicas e valores associados: Se você precisar de uma coleção que armazene pares chave-valor, o Dictionary ou SortedDictionary pode ser mais apropriado.

Mais exemplos práticos

//instanciação dos conjuntos
HashSet<int> A = new HashSet<int>();
HashSet<int> B = new HashSet<int>();
    
//adicionar números aos conjuntos
A.Add(2);
A.Add(4);
A.Add(5);
B.Add(5);
B.Add(6);
B.Add(9);

Para percorrer os elementos dos conjuntos será necessário utilizar o foreach:

foreach(int x in A) //para cada inteiro x dentro do conjunto A...
   Console.WriteLine(x);

Para verificar se o conjunto A contém um valor específico:

if(A.Contains(x))

Para remover um elemento do conjunto:

A.Remove(x);

Para efetuar a diferença entre conjuntos:

A.ExceptWith(B); //remove do conjunto A os elementos que estão em B

Para efetuar a união entre conjuntos:

A.UnionWith(B); //adiciona no conjunto A todos que estão em B mas que não estão em A

Para efetuar a interseção entre conjuntos:

A.IntersectWith(B); //mostra elementos que estão contidos tanto em A quanto em B

O HashSet em C# é uma excelente escolha para armazenar coleções de elementos únicos de forma eficiente e realizar operações de conjunto. Ele é ideal quando você precisa garantir a unicidade dos itens e precisa de desempenho rápido nas operações de adição e busca. Agora que você já conhece as principais funcionalidades, está pronto para utilizar essa poderosa estrutura de dados em seus projetos C#.

Dúvidas ou sugestões sobre conjuntos em C#? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
 https://youtube.com/criandobits

Tags: conjuntos | hashset