Estructura de Datos Compleja

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.

Ejemplo de estructura de nodo:

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

Utilidad 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.

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 padre. Los árboles binarios permiten una organización eficiente de los datos y una búsqueda rápida gracias a su estructura lógica de "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) según el principio LIFO - (Last In, First Out).

Ejemplo de pila usando un arreglo:

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

MAX_SIZE - el número máximo de elementos que una pila puede contener.

// 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, donde el último elemento añadido es el primero en ser retirado.

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, lo que hace que los programas sean más organizados y eficientes.