Pilas Estáticas

¿Qué son las pilas?

Las pilas son una implementación concreta y acotada de una lista; es decir, tienen la capacidad de almacenar información coherente e indexada, pero limitan el acceso y la modificación de la información contenida en ellas. Así, una pila busca estructurar la información de tal modo que solo sea posible acceder al último elemento agregado (y no sustraído) de la misma. A esto se le llama Top y representa al elemento que se encuentra encima de todos los demás dentro de la pila.
Por estas características, a estas estructuras se les conoce como estructuras de tipo LIFO (Last In First Out). Suele hacerse un símil con una pila de trastes: para poder lavar los inferiores, es necesario primero lavar los superiores. Solo habremos terminado nuestra labor cuando hasta el último plato (el primero que colocamos) haya sido removido.

Pila estática.

Así, una pila estática —tal como la lista estática— es una implementación concreta basada en arreglos. Por lo tanto, tiene las ventajas y desventajas ya conocidas: para los principiantes es muy fácil de entender, utilizar e implementar, con la consecuencia de un posible mal uso de memoria y poca flexibilidad si se desea cambiar su tamaño. Sin embargo, a diferencia de las listas estáticas que suelen ser poco utilizadas, las pilas tienen aplicaciones muy variadas dentro de la informática. La más importante de ellas es en la administración de la memoria de los procesos, llamadas y paso de argumentos a funciones.

Procesos.

A nivel de sistema operativo, usualmente cuando un proceso es cargado en la memoria RAM, se le asignan diferentes secciones conocidas como: code, que —como su nombre indica— es el espacio donde se encuentran las instrucciones ejecutables del programa; data, que contiene las constantes globales compartidas por todo el programa, así como cadenas de texto y otros literales; heap, que almacena los datos reservados en tiempo de ejecución (es decir, memoria dinámica) a la cual se le asignan las direcciones bajas; y finalmente, stack o pila, con asignación de direcciones altas y que guarda mucha información relevante en tiempo de ejecución, desglosada en la [Tabla 2].

Como podemos ver, esta estructura tiene una aplicación fundamental en el funcionamiento de un sistema operativo y en la correcta ejecución de nuestros programas.

Implementación.

Ya que hemos definido qué son las pilas y algunos de los usos más interesantes que presentan, ha llegado el momento de implementarlas. Para ello, haremos el caso más simple: una pila estática. No puede reasignarse su tamaño en tiempo de ejecución (tiene un tamaño fijo desde su creación) y no podemos consultar ni el top ni ningún elemento intermedio de la pila.
Así, para empezar, necesitaremos crear nuestro constructor y destructor, como ya hicimos con la lista estática.

typedef struct _static_stack {
	int *array;
	size_t capacity, size;
} StaticStack;

StaticStack *new_static_stack(size_t capacity) {
	StaticStack *stack = (StaticStack*) malloc( sizeof(StaticStack) );
	if(!stack) {
		fprintf(stderr, "Error al reservar memoria para la pila estática.");
		exit(EXIT_FAILURE);
	}

	stack->array = (int*) malloc( capacity * sizeof(int) );
	if(!stack->array) {
		fprintf(stderr, "Error al reservar memoria para el arreglo de la pila estática.");
		exit(EXIT_FAILURE);
	}

	stack->capacity = capacity;
	stack->size = 0;

	return stack;
}

void delete_static_stack(StaticStack *stack) {
	if(stack->size != 0) {
		for(int i = 0; i < stack->size; i++) {
			stack->array[i] = 0;
		}
	}
	free(stack->array);
	stack->capacity = 0;
	stack->size = 0;
	free(stack);
}

Aquí podemos ver que, al crear la pila, asignamos el tamaño fijo que pasamos como argumento y creamos el arreglo necesario para usarla correctamente. En el destructor, por otro lado, hacemos el proceso inverso: limpiamos la información y liberamos el espacio usado.

Métodos de una Pila.

Nuestras pilas necesitan de dos métodos fundamentales: push y pop, es decir, inserción al final y eliminación del final. Al tener una implementación basada en arreglos, estos métodos son muy sencillos, pues solo necesitamos un índice de referencia que se incremente o decremente según el caso. Es opcional (aunque recomendable) borrar la información del último índice antes de decrementar, para no dejar información en la RAM que pueda ser encontrada por algún programa malicioso.

bool static_stack_push(StaticStack *stack, int value) {
	if(static_stack_is_full(*stack)) {
		return false;
	}

	stack->array[stack->size] = value;
	stack->size++;

	return true;
}

int static_stack_pop(StaticStack *stack) {
	if(static_stack_is_void(*stack)) {
		return ERROR_VALUE;
	}

	stack->size--;
	int value = stack->array[stack->size];

	return value;
}

bool static_stack_is_void(StaticStack stack) {
	return stack.size == 0;
}

bool static_stack_is_full(StaticStack stack) {
	return stack.size == stack.capacity;
}

Asimismo, podemos crear de forma opcional nuestros métodos auxiliares Is Full e Is Void, que verifican si queda espacio disponible en la pila o si esta está vacía, respectivamente.

Eficiencia.

En general, al tener dos métodos tan sencillos, una pila es una estructura altamente eficiente. No necesitamos operaciones complejas y, al no requerir reorganizar la información, evitamos los problemas que se presentaban con las listas estáticas.

Conclusiones.

Las pilas son estructuras de datos fundamentales en informática, cuyo comportamiento basado en el principio LIFO (Last In, First Out) permite organizar y administrar la información de forma controlada y eficiente. Su simplicidad estructural, especialmente en implementaciones estáticas, facilita su comprensión e integración en múltiples contextos, desde algoritmos hasta sistemas operativos.
A lo largo de este recorrido, comprendimos no solo su definición y aplicaciones más comunes, sino también los aspectos técnicos que intervienen en su implementación, como el uso de arreglos, gestión de memoria, y la creación de funciones específicas para insertar y eliminar elementos. Además, exploramos el papel crítico que desempeñan en la gestión de memoria a nivel de sistema, donde el stack es esencial para el manejo de llamadas a funciones, almacenamiento temporal y protección del flujo de ejecución.
Gracias a su eficiencia —con operaciones de inserción y eliminación en tiempo constante O(1)—, y su versatilidad —desde el análisis sintáctico hasta la recursión—, las pilas continúan siendo una herramienta esencial para todo desarrollador. Comprenderlas a fondo es un paso clave en el dominio de la programación estructurada y la construcción de software confiable.
Puedes ver el vídeo relacionado en: Canal de Youtube