Estruturas de dados em C# (Como funciona para desenvolvedores)

Matrizes: Os Fundamentos da Organização de Dados

Os arrays estão entre as estruturas de dados mais básicas e amplamente utilizadas em C#. Eles armazenam elementos do mesmo tipo de dados em locais de memória contíguos, permitindo acesso eficiente aos elementos por meio de um índice. Os arrays são ideais para situações em que o número de elementos é conhecido antecipadamente e não se altera.

int[] numbers = new int[5] {1, 2, 3, 4, 5};

int[] numbers = new int[5] {1, 2, 3, 4, 5};

Dim numbers() As Integer = {1, 2, 3, 4, 5}

Ao acessar os elementos por meio de seus índices, os arrays facilitam a recuperação de dados, com o item inicial localizado no índice 0. Por exemplo, numbers[0] acessaria o primeiro elemento do array numbers , que é 1 .

Listas: Coleções de Dados Dinâmicas

Ao contrário dos arrays, as listas em C# permitem redimensionamento dinâmico, tornando-as adequadas para cenários em que o número de elementos pode mudar ao longo do tempo. O C# suporta vários tipos de dados e, por meio de estruturas de dados como listas, permite o armazenamento com segurança de tipos.

List<int> numbers = new List<int> {1, 2, 3, 4, 5};
numbers.Add(6); // Adds a new element to the list

List<int> numbers = new List<int> {1, 2, 3, 4, 5};
numbers.Add(6); // Adds a new element to the list

Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
numbers.Add(6) ' Adds a new element to the list

As listas são versáteis, permitindo adicionar, remover e acessar elementos livremente, sem se preocupar com o tamanho dos dados subjacentes.

Dicionários: Associações Chave-Valor

Os dicionários armazenam associações na forma de pares chave-valor, tornando-os ideais para situações em que você precisa acessar valores com base em uma chave exclusiva. Isso é especialmente útil no gerenciamento de sessões de usuário, configurações ou qualquer cenário que exija uma pesquisa por chave.

Dictionary<string, int> ages = new Dictionary<string, int>();
ages.Add("Alice", 30);
ages.Add("Bob", 25);

Dictionary<string, int> ages = new Dictionary<string, int>();
ages.Add("Alice", 30);
ages.Add("Bob", 25);

Dim ages As New Dictionary(Of String, Integer)()
ages.Add("Alice", 30)
ages.Add("Bob", 25)

Neste exemplo, o nome de cada pessoa está associado à sua idade, permitindo acesso rápido à idade de um indivíduo com base em seu nome.

Pilhas e filas: gerenciando coleções

As pilhas operam segundo o princípio "último a entrar, primeiro a sair" (LIFO, na sigla em inglês), o que as torna perfeitas para gerenciar coleções onde é necessário acessar primeiro o elemento adicionado mais recentemente, como em mecanismos de desfazer ou sistemas de agendamento de tarefas.

Stack<string> books = new Stack<string>();
books.Push("Book 1");
books.Push("Book 2");
string lastAddedBook = books.Pop(); // Removes and returns "Book 2"

Stack<string> books = new Stack<string>();
books.Push("Book 1");
books.Push("Book 2");
string lastAddedBook = books.Pop(); // Removes and returns "Book 2"

Dim books As New Stack(Of String)()
books.Push("Book 1")
books.Push("Book 2")
Dim lastAddedBook As String = books.Pop() ' Removes and returns "Book 2"

As filas, por outro lado, operam com base no princípio "primeiro a entrar, primeiro a sair" (FIFO, na sigla em inglês). São úteis em cenários como o agendamento de tarefas de impressão ou o gerenciamento de solicitações de atendimento ao cliente.

Queue<string> customers = new Queue<string>();
customers.Enqueue("Customer 1");
customers.Enqueue("Customer 2");
string firstCustomer = customers.Dequeue(); // Removes and returns "Customer 1"

Queue<string> customers = new Queue<string>();
customers.Enqueue("Customer 1");
customers.Enqueue("Customer 2");
string firstCustomer = customers.Dequeue(); // Removes and returns "Customer 1"

Dim customers As New Queue(Of String)()
customers.Enqueue("Customer 1")
customers.Enqueue("Customer 2")
Dim firstCustomer As String = customers.Dequeue() ' Removes and returns "Customer 1"

Listas encadeadas: estruturas de dados personalizadas

Listas encadeadas consistem em nós que contêm dados e uma referência ao próximo nó na sequência, permitindo a inserção e remoção eficiente de elementos. São especialmente úteis em aplicações onde a manipulação de elementos individuais é frequente, como uma lista de contatos em uma rede social.

public class Node
{
    public int data;
    public Node next;
    public Node(int d) { data = d; next = null; }
}

public class LinkedList
{
    public Node head;

    // Adds a new node with the given data at the head of the list
    public void Add(int data)
    {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // Displays the data for each node in the list
    public void Display()
    {
        Node current = head;
        while (current != null)
        {
            Console.WriteLine(current.data);
            current = current.next;
        }
    }
}

public class Node
{
    public int data;
    public Node next;
    public Node(int d) { data = d; next = null; }
}

public class LinkedList
{
    public Node head;

    // Adds a new node with the given data at the head of the list
    public void Add(int data)
    {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // Displays the data for each node in the list
    public void Display()
    {
        Node current = head;
        while (current != null)
        {
            Console.WriteLine(current.data);
            current = current.next;
        }
    }
}

Public Class Node
	Public data As Integer
	Public [next] As Node
	Public Sub New(ByVal d As Integer)
		data = d
		[next] = Nothing
	End Sub
End Class

Public Class LinkedList
	Public head As Node

	' Adds a new node with the given data at the head of the list
	Public Sub Add(ByVal data As Integer)
		Dim newNode As New Node(data)
		newNode.next = head
		head = newNode
	End Sub

	' Displays the data for each node in the list
	Public Sub Display()
		Dim current As Node = head
		Do While current IsNot Nothing
			Console.WriteLine(current.data)
			current = current.next
		Loop
	End Sub
End Class

Árvores e Grafos: Estruturas de Dados Complexas

Árvores, como as árvores binárias, organizam os dados de forma hierárquica, permitindo que operações como busca, inserção e exclusão sejam realizadas de maneira eficiente. Árvores binárias, por exemplo, são fundamentais na implementação de algoritmos como a busca binária e a busca em largura.

Os grafos, compostos por nós (vértices) e arestas (conexões), são usados ​​para representar redes, como grafos sociais ou mapas de transporte. Tanto as árvores quanto os grafos são importantes para resolver problemas complexos que envolvem dados hierárquicos ou relações em rede.

Critérios para a escolha de estruturas de dados

1. Complexidade da operação: Considere a rapidez com que você precisa executar operações comuns. Por exemplo, se for necessário acessar elementos com frequência com base em uma chave, uma tabela hash (implementada em C# como um dicionário ) pode ser a opção mais eficiente.
2. Eficiência de memória: Avalie quanta memória a estrutura de dados consome, especialmente se você estiver trabalhando com uma grande quantidade de dados. Estruturas como listas encadeadas podem ser mais eficientes em termos de memória para certas operações do que arrays, porque não alocam memória para elementos não utilizados.
3. Facilidade de implementação: Algumas estruturas de dados podem oferecer implementações mais simples para o seu caso de uso específico. Por exemplo, se você precisar adicionar e remover elementos com frequência apenas de uma extremidade, uma Pilha ou Fila pode ser mais simples de usar e entender do que uma Lista Ligada .
4. Tamanho e escalabilidade dos dados: Considere se o tamanho dos seus dados é fixo ou dinâmico. Os arrays são ideais para coleções de dados de tamanho fixo, enquanto listas ou listas encadeadas são mais adequadas para coleções de dados que precisam crescer ou diminuir dinamicamente.

Exemplo: Gerando um PDF a partir de uma lista de dados

Considere um cenário em que você precisa gerar um relatório a partir de uma lista de nomes e endereços de e-mail de clientes. Primeiro, você estruturaria seus dados em uma lista de uma classe personalizada, Customer , e depois usaria o IronPDF para criar um documento PDF a partir dessa lista.

using IronPdf;
using System.Collections.Generic;

// Define a customer class with properties for name and email
public class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        // Set your IronPDF license key here. Replace "License-Key" with your actual key
        License.LicenseKey = "License-Key";

        // Create a list of customers
        List<Customer> customers = new List<Customer>
        {
            new Customer { Name = "Alice Johnson", Email = "alice@example.com" },
            new Customer { Name = "Bob Smith", Email = "bob@example.com" }
        };

        // Initialize the HTML to PDF converter
        var renderer = new ChromePdfRenderer();

        // Generate HTML content from the list of customers
        var htmlContent = "<h1>Customer List</h1><ul>";
        foreach (var customer in customers)
        {
            htmlContent += $"<li>{customer.Name} - {customer.Email}</li>";
        }
        htmlContent += "</ul>";

        // Convert HTML to PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF document
        pdf.SaveAs("CustomerList.pdf");
    }
}

using IronPdf;
using System.Collections.Generic;

// Define a customer class with properties for name and email
public class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        // Set your IronPDF license key here. Replace "License-Key" with your actual key
        License.LicenseKey = "License-Key";

        // Create a list of customers
        List<Customer> customers = new List<Customer>
        {
            new Customer { Name = "Alice Johnson", Email = "alice@example.com" },
            new Customer { Name = "Bob Smith", Email = "bob@example.com" }
        };

        // Initialize the HTML to PDF converter
        var renderer = new ChromePdfRenderer();

        // Generate HTML content from the list of customers
        var htmlContent = "<h1>Customer List</h1><ul>";
        foreach (var customer in customers)
        {
            htmlContent += $"<li>{customer.Name} - {customer.Email}</li>";
        }
        htmlContent += "</ul>";

        // Convert HTML to PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF document
        pdf.SaveAs("CustomerList.pdf");
    }
}

Imports IronPdf
Imports System.Collections.Generic

' Define a customer class with properties for name and email
Public Class Customer
	Public Property Name() As String
	Public Property Email() As String
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Set your IronPDF license key here. Replace "License-Key" with your actual key
		License.LicenseKey = "License-Key"

		' Create a list of customers
		Dim customers As New List(Of Customer) From {
			New Customer With {
				.Name = "Alice Johnson",
				.Email = "alice@example.com"
			},
			New Customer With {
				.Name = "Bob Smith",
				.Email = "bob@example.com"
			}
		}

		' Initialize the HTML to PDF converter
		Dim renderer = New ChromePdfRenderer()

		' Generate HTML content from the list of customers
		Dim htmlContent = "<h1>Customer List</h1><ul>"
		For Each customer In customers
			htmlContent &= $"<li>{customer.Name} - {customer.Email}</li>"
		Next customer
		htmlContent &= "</ul>"

		' Convert HTML to PDF
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

		' Save the PDF document
		pdf.SaveAs("CustomerList.pdf")
	End Sub
End Class

Neste exemplo, o IronPDF funciona em conjunto com a estrutura de dados List<Customer>, demonstrando a capacidade da biblioteca de transformar dados estruturados em C# em documentos PDF de qualidade profissional.