As estruturas de dados são formas específicas de organizar e armazenar dados em um programa, permitindo manipulação eficiente. A escolha correta da estrutura de dados impacta diretamente no desempenho da aplicação, influenciando o tempo de execução e o uso de memória. Neste artigo, vamos explorar as principais estruturas de dados em C#, explicar como funcionam e quando utilizá-las.
O que são estruturas de dados?
As estruturas de dados são formas específicas de organizar e armazenar dados de maneira que possibilitem uma manipulação eficiente. Elas são essenciais para garantir que as operações sobre os dados, como inserção, remoção, e acesso, sejam feitas de forma rápida e eficiente.
O conceito de estrutura de dados envolve a organização dos dados em diferentes formatos para atender a necessidades específicas, como:
Eficiência no uso da memória: algumas estruturas de dados são mais compactas e otimizadas para armazenar grandes volumes de informações.
Eficiência na execução de operações: dependendo do tipo de estrutura, certas operações podem ser mais rápidas, como buscar um elemento ou adicionar um novo item.
Estruturas de dados lineares
As estruturas de dados lineares são aquelas em que os elementos são organizados de forma sequencial, ou seja, cada elemento tem um único predecessor e um único sucessor (exceto os elementos nas extremidades). Elas são ideais quando há a necessidade de acessar ou manipular dados de forma simples e direta, respeitando a ordem de inserção.
Vamos conhecer algumas das estruturas lineares mais comuns em C#:
Array
- Acesso rápido aos elementos, usando o índice.
- Tamanho fixo, o que significa que o número de elementos deve ser conhecido de antemão.
- A memória é alocada de forma contígua, ou seja, os elementos são armazenados em sequência, um logo após o outro, o que torna o acesso mais rápido.
A criação de um array pode ser feita da seguinte forma:
int[] numeros = { 1, 2, 3, 4, 5 };
Console.WriteLine(numeros[2]);
O código acima, acessa o elemento que está na posição 2 que é igual a 3.
List<T>
A classe “List<T>” é uma coleção dinâmica em C# que permite armazenar elementos de forma sequencial. Diferente de um array, o tamanho da lista pode ser alterado dinamicamente, o que a torna mais flexível.
Suas características são:
- Capacidade de redimensionar-se automaticamente conforme os elementos são adicionados ou removidos.
- Acesso a elementos via índice, como em um array, mas com a vantagem de não precisar definir o tamanho de antemão.
A sua construção pode ser feita da seguinte forma:
List<int> numeros = new List<int> { 1, 2, 3, 4, 5 };
numeros.Add(6);
Console.WriteLine(numeros[5]);
No código acima, nós criamos uma lista com 5 elementos. Após isso, adicionamos mais um elemento (6). Por fim, apresentamos no console o elemento que está na posição 5 da lista, que neste caso é o 6.
LinkedList<T>
- Cada elemento contém um ponteiro para o próximo elemento, o que permite inserções e remoções eficientes, especialmente no início ou no meio da lista.
- Acesso sequencial aos elementos, não é possível acessar diretamente um elemento por índice.
Agora vamos ver um exemplo de LinkedList:
LinkedList<int> numeros = new LinkedList<int>();
numeros.AddLast(1);
numeros.AddLast(2);
numeros.AddFirst(0);
Console.WriteLine(numeros.First.Value);
No código acima, criamos uma LinkedList de inteiros e adicionamos três valores: dois no final da lista e um no início. Em seguida, utilizamos a propriedade First para acessar o primeiro valor da lista, que, neste caso, é o 0. A LinkedList permite uma navegação flexível, sendo possível adicionar ou remover elementos em qualquer posição de forma eficiente.
Quando usar: útil quando você precisa realizar inserções e remoções frequentes em qualquer posição da lista, especialmente no início ou no meio, onde uma List<T> poderia ser menos eficiente.
Stack<T>
A Stack<T> e uma estrutura de dados do tipo LIFO (Last In, First Out). Isso significa que o último item a ser inserido é o primeiro a ser removido, ou seja, a pilha funciona como uma “pilha de pratos”, onde você adiciona um prato no topo e retira o último prato colocado.
Esse comportamento é útil em situações em que você precisa processar dados de trás para frente ou manter um controle sobre operações anteriores, como em um histórico de navegação ou execução de funções recursivas.
Vamos ver o código do exemplo acima:
Stack<int> pilha = new Stack<int>();
pilha.Push(1);
pilha.Push(2);
Console.WriteLine(pilha.Pop());
Console.WriteLine(pilha.Pop());
Quando usamos o “Pop()”, ele remove o último elemento inserido, que, no caso, é o 2, seguido pelo 1.
Queue<T>
A Queue<T> é uma estrutura de dados do tipo FIFO (First In, First Out). Isso significa que o primeiro item a ser inserido é o primeiro a ser removido.
Imagine uma fila de pessoas, onde a primeira pessoa a entrar na fila é a primeira a ser atendida. Esse comportamento é útil em situações onde os dados precisam ser processados na ordem em que foram recebidos, como em sistemas de processamento de tarefas ou controle de requisições.
Vamos ver o código do exemplo acima:
Queue<int> fila = new Queue<int>();
fila.Enqueue(1);
fila.Enqueue(2);
Console.WriteLine(fila.Dequeue());
Console.WriteLine(fila.Dequeue());
No código acima, o “Dequeue()” remove o primeiro elemento inserido. Assim, o primeiro Dequeue remove o 1 e o segundo Dequeue remove o 2, seguindo o princípio FIFO.
Se você quiser se aprofundar mais sobre o Queue, pode conferir o artigo completo sobre o assunto.
Acelere a sua carreira conosco!
Se você é Desenvolvedor .NET Júnior e quer acelerar sua carreira até nível Pleno com salário de R$7k+, ou mesmo busca a primeira vaga, conheça a Mentoria .NET Start: Clique aqui
Se é Desenvolvedor .NET Pleno ou Sênior e quer virar referência técnica em sua equipe e mercado, com salário de R$10k+, conheça a Mentoria .NET Expert: Clique aqui
Conclusão
As estruturas de dados em C# são fundamentais para otimizar o gerenciamento de dados nas suas aplicações. Compreender como e quando usá-las pode melhorar significativamente a performance do seu código. Escolher a estrutura certa, torna seu código mais eficiente, fácil de manter e capaz de resolver problemas de forma mais eficaz.