Datastrukturer gør det muligt for programmører at gemme, organisere og håndtere data effektivt. Enkle arrays eller sekventiel lagring er ofte ikke tilstrækkelige til komplekse opgaver, hvilket er grunden til, at strukturer som lister, træer og hash-tabeller anvendes.

I C giver strukturer (struct) en fleksibel måde at implementere mange af disse datastrukturer på.

Lænkede lister

En lænket liste er nyttig, når antallet af elementer kan ændre sig dynamisk. Hver node indeholder data og en pointer til den næste node.

Eksempel på nodestruktur:

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

Hver node indeholder et data-felt og en next-pointer. Dette muliggør tilføjelse eller fjernelse af elementer hvor som helst i listen uden at skulle omorganisere hele strukturen, i modsætning til arrays.

Hash Table

Hash-tabeller muliggør hurtig hentning af data ved hjælp af en nøgle. En hash-funktion konverterer nøglen til et array-indeks, hvor værdien gemmes.

Eksempel på implementering af hash-tabel:

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;
}

Hvert element i hash-tabellen er en knude i en kædet liste, der indeholder en nøgle og en værdi. Hash-funktionen konverterer nøglen til et array-indeks, hvilket muliggør hurtige opslag, selv med store datamængder.

Træer

Træer er nyttige til hierarkiske data, hurtig søgning, indsættelse og sletning.

Et binært træ er et træ, hvor hver node har højst to børn: venstre og højre.

Et eksempel på en implementering af et binært træ:

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

En node kan være forælder til sine børn og samtidig være barn af sin forælder. Binære træer muliggør effektiv dataorganisering og hurtig søgning på grund af deres logiske "venstre-højre" struktur.

Stack

Bruges til at modellere netværk og relationer.

En stack er en datastruktur, hvor elementer tilføjes (push) og fjernes (pop) i henhold til LIFO-princippet - (Last In, First Out).

Eksempel på stack ved brug af et 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;
}

Elementet tilføjes øverst i stakken (top). Stakke muliggør hurtig tilføjelse og fjernelse af elementer, hvor det sidst tilføjede element er det første, der fjernes.

Brugen af strukturer i C gør det muligt at oprette fleksible og kraftfulde datastrukturer såsom arrays, linked lists, hash-tabeller, træer og stakke. Hver struktur er optimeret til specifikke opgaver, hvilket gør programmer mere organiserede og effektive.