Las estructuras de datos permiten a los programadores almacenar, organizar y gestionar datos de manera eficiente. Los arreglos simples o el almacenamiento secuencial a menudo no son suficientes para tareas complejas, por lo que se utilizan estructuras como listas, árboles y tablas hash.

En C, las estructuras (struct) ofrecen una forma flexible de implementar muchas de estas estructuras de datos.

Listas enlazadas

Una lista enlazada es útil cuando la cantidad de elementos puede cambiar dinámicamente. Cada nodo contiene datos y un puntero al siguiente nodo.

Estructura de nodo de ejemplo:

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

Cada nodo contiene un campo data y un puntero next. Esto permite agregar o eliminar elementos en cualquier parte de la lista sin reorganizar toda la estructura, a diferencia de los arreglos.

Tabla hash

Las tablas hash permiten recuperar datos rápidamente utilizando una clave. Una función hash convierte la clave en un índice de arreglo, donde se almacena el valor.

Ejemplo de implementación de una tabla 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 en la tabla hash es un nodo de lista enlazada que contiene una clave y un valor. La función hash convierte la clave en un índice de arreglo, permitiendo búsquedas rápidas incluso con grandes volúmenes de datos.

Árboles

Los árboles son útiles para datos jerárquicos, búsqueda rápida, inserción y eliminación.

Un árbol binario es un árbol donde cada nodo tiene como máximo dos hijos: izquierdo y derecho.

Un ejemplo de implementación de un árbol binario:

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

Un nodo puede ser padre de sus hijos y, al mismo tiempo, hijo de su propio padre. Los árboles binarios proporcionan una organización eficiente de los datos y una búsqueda rápida gracias a su estructura lógica "izquierda-derecha".

Pila

Utilizada para modelar redes y relaciones.

Una pila es una estructura de datos en la que los elementos se agregan (push) y se eliminan (pop) de acuerdo con el principio LIFO - (Last In, First Out; último en entrar, primero en salir).

Ejemplo de pila utilizando un arreglo:

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

El elemento se añade en la parte superior de la pila (top). Las pilas permiten una adición y eliminación rápida de elementos, siendo el último elemento añadido el primero en ser eliminado.

El uso de estructuras en C permite crear estructuras de datos flexibles y potentes como arreglos, listas enlazadas, tablas hash, árboles y pilas. Cada estructura está optimizada para tareas específicas, haciendo que los programas sean más organizados y eficientes.