Struktury danych w języku C# (jak to działa dla programistów)

Tablice: Podstawy organizacji danych

Tablice należą do najprostszych i najczęściej używanych struktur danych w C#. Przechowują elementy tego samego typu danych w sąsiadujących lokalizacjach pamięci, umożliwiając efektywny dostęp do elementów za pomocą indeksu. Tablice są idealne w sytuacjach, gdy liczba elementów jest znana z góry i nie ulega zmianie.

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}

Dzięki dostępowi do elementów za pośrednictwem ich indeksu, tablice ułatwiają pobieranie danych, z pierwszym elementem zlokalizowanym pod indeksem 0. Na przykład, numbers[0] da dostęp do pierwszego elementu tablicy numbers, który to 1.

Listy: Dynamiczne kolekcje danych

W przeciwieństwie do tablic, listy w C# oferują dynamiczne zmiany rozmiaru, co sprawia, że są odpowiednie w scenariuszach, gdzie liczba elementów może zmieniać się z czasem. C# obsługuje różne typy danych, a dzięki takim strukturom danych jak listy, pozwala na bezpieczne typowanie przechowywania.

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

Listy są wszechstronne, umożliwiając swobodne dodawanie, usuwanie i dostęp do elementów bez obawy o rozmiar danych leżących u ich podstaw.

Słowniki: Powiązania klucz-wartość

Słowniki przechowują powiązania w postaci par klucz-wartość, co czyni je idealnymi w sytuacjach, gdy trzeba uzyskać dostęp do wartości na podstawie unikalnego klucza. Jest to szczególnie przydatne w zarządzaniu sesjami użytkownika, konfiguracjami lub w każdej sytuacji wymagającej wyszukiwania po kluczu.

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)

W tym przykładzie, imię każdej osoby jest powiązane z jej wiekiem, co pozwala na szybki dostęp do wieku danej osoby na podstawie jej imienia.

Stos i kolejki: Zarządzanie kolekcjami

Stos działa na zasadzie ostatni na wejściu, pierwszy na wyjściu (LIFO), co czyni go doskonałym do zarządzania kolekcjami, w których trzeba uzyskać dostęp do najnowszego dodanego elementu jako pierwszego, na przykład w mechanizmach cofania lub systemach harmonogramowania zadań.

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"

Kolejki natomiast działają na zasadzie pierwszy na wejściu, pierwszy na wyjściu (FIFO). Są przydatne w scenariuszach, jak harmonogramowanie zadań drukarki czy obsługi zapytań serwisowych.

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"

Listy wiązane: Niestandardowe struktury danych

Listy wiązane składają się z węzłów zawierających dane i odwołanie do następnego węzła w sekwencji, co pozwala na efektywne wstawianie i usuwanie elementów. Są szczególnie przydatne w aplikacjach, gdzie częsta jest manipulacja indywidualnymi elementami, takich jak lista kontaktów w aplikacji społecznościowej.

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

Drzewa i grafy: Złożone struktury danych

Drzewa, takie jak drzewa binarne, organizują dane w sposób hierarchiczny, co pozwala na skuteczne wykonywanie operacji takich jak wyszukiwanie, wstawianie i usuwanie. Drzewa binarne, na przykład, są fundamentalne we wdrażaniu algorytmów takich jak wyszukiwanie binarne i przeszukiwanie wszerz.

Grafy, składające się z węzłów (wierzchołków) i krawędzi (połączeń), są używane do reprezentacji sieci, takich jak grafy społecznościowe czy mapy transportowe. Zarówno drzewa, jak i grafy są ważne w rozwiązywaniu złożonych problemów związanych z danymi hierarchicznymi czy relacjami sieciowymi.

Kryteria wyboru struktur danych

1. Złożoność operacji: Rozważ, jak szybko musisz wykonywać typowe operacje. Na przykład, jeśli wymagany jest częsty dostęp do elementów na podstawie klucza, najbardziej efektywnym wyborem może być tabela mieszania (zaimplementowana w C# jako Dictionary).
2. Efektywność pamięciowa: Oceń, ile pamięci struktura danych zużywa, zwłaszcza jeśli pracujesz z dużą ilością danych. Struktury takie jak listy wiązane mogą być bardziej efektywne pamięciowo dla niektórych operacji niż tablice, ponieważ nie przydzielają pamięci na niewykorzystane elementy.
3. Łatwość implementacji: Niektóre struktury danych mogą oferować prostsze implementacje dla twojego specyficznego przypadku użycia. Na przykład, jeśli musisz często dodawać i usuwać elementy tylko z jednego końca, Stos lub Kolejka mogą być prostsze do użycia i zrozumienia niż LinkedList.
4. Rozmiar danych i skalowalność: Rozważ, czy rozmiar twoich danych jest stały czy dynamiczny. Tablice są idealne dla kolekcji danych o stałym rozmiarze, podczas gdy listy lub listy wiązane są lepsze dla kolekcji danych, które muszą dynamicznie rosnać lub maleć.

Przykład: Generowanie PDF z listy danych

Rozważ scenariusz, w którym trzeba wygenerować raport z listy nazwisk klientów i adresów e-mail. Najpierw należy ustrukturyzować swoje dane w List niestandardowej klasy, Customer, a następnie użyć IronPDF do stworzenia dokumentu PDF z tej listy.

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

W tym przykładzie IronPDF współpracuje z danymi struktury List, co pokazuje zdolność biblioteki do przekształcania ustrukturyzowanych danych C# na profesjonalnej jakości dokumenty PDF.