Estruturas de dados permitem que programadores armazenem, organizem e gerenciem dados de forma eficiente. Arrays simples ou armazenamento sequencial geralmente não são suficientes para tarefas complexas, por isso estruturas como listas, árvores e tabelas hash são utilizadas.

Em C, estruturas (struct) oferecem uma maneira flexível de implementar muitas dessas estruturas de dados.

Listas Ligadas

Uma lista ligada é útil quando o número de elementos pode mudar dinamicamente. Cada nó contém dados e um ponteiro para o próximo nó.

Estrutura de nó de exemplo:

struct Node {
    int data;           // data in node
    struct Node* next;  // pointer to next node
};

Cada nó contém um campo data e um ponteiro next. Isso permite adicionar ou remover elementos em qualquer posição da lista sem reorganizar toda a estrutura, diferentemente dos arrays.

Tabela Hash

Tabelas hash permitem recuperar dados rapidamente usando uma chave. Uma função hash converte a chave em um índice de array, onde o valor é armazenado.

Exemplo de implementação de tabela hash:

struct Node {
    char* key;          // key
    int value;          // value
    struct Node* next;  // pointer to next node
};

struct HashTable {
    struct Node** table; // array of node pointers
    int size;            // table size
};

unsigned int hashFunction(char* key, int size) {
    unsigned int hash = 0;
    while (*key) {
        hash += *key++;
    }
    return hash % size;
}

Cada elemento na tabela hash é um nó de lista encadeada contendo uma chave e um valor. A função de hash converte a chave em um índice de array, permitindo buscas rápidas, mesmo com grandes volumes de dados.

Árvores

Árvores são úteis para dados hierárquicos, busca rápida, inserção e remoção.

Uma árvore binária é uma árvore onde cada nó possui no máximo dois filhos: esquerdo e direito.

Um exemplo de implementação de uma árvore binária:

struct node
{
	int data;
	struct node* left; 
	struct node* right; 
};

Um nó pode ser pai de seus filhos e também filho de seu pai. Árvores binárias oferecem organização eficiente de dados e busca rápida devido à sua estrutura lógica "esquerda-direita".

Pilha

Utilizada para modelar redes e relacionamentos.

Uma pilha é uma estrutura de dados na qual os elementos são adicionados (push) e removidos (pop) de acordo com o princípio LIFO - (Last In, First Out; último a entrar, primeiro a sair).

Exemplo de pilha utilizando um array:

// Stack structure
typedef struct {
    int data[MAX_SIZE]; 
    int top;
} Stack;

MAX_SIZE - the maximum number of elements a stack can contain.

// Push an element onto the stack
void push(Stack *stack, int value) {
    stack->data[++stack->top] = value;  // Increment top and add the element
    printf("Element %d pushed onto the stack\n", value);
}

// Pop an element from the stack
int pop(Stack *stack) {
    int value = stack->data[stack->top--];  // Retrieve the element and decrement top
    printf("Element %d popped from the stack\n", value);
    return value;
}

O elemento é adicionado ao topo da pilha (top). Pilhas permitem adição e remoção rápidas de elementos, sendo que o último elemento adicionado é o primeiro a ser removido.

O uso de estruturas em C possibilita a criação de estruturas de dados flexíveis e poderosas, como arrays, listas encadeadas, tabelas hash, árvores e pilhas. Cada estrutura é otimizada para tarefas específicas, tornando os programas mais organizados e eficientes.