Pila genérica

Parte de la sección Object Oriented Programming del Journey de C de Coddy — lección 60 de 61.

Desafío

Fácil

Una pila (stack) es una estructura de datos fundamental que sigue el principio Last-In-First-Out (LIFO): el último elemento añadido es el primero en ser eliminado. Piensa en una pila de platos: añades en la parte superior y retiras de la parte superior.

Vamos a construir una Pila Genérica, una estructura de datos versátil que puede almacenar cualquier tipo de dato utilizando punteros void*. Tu pila seguirá el principio Last-In-First-Out, completa con todas las operaciones esenciales.

Organizarás tu código en tres archivos:

stack.h: Define la estructura Stack con tres miembros: un arreglo void** para los elementos, un int para el índice superior (siguiente espacio libre) y un int para la capacidad. Declara los prototipos de las funciones para crear una pila (que recibe una capacidad), añadir un elemento (push), extraer un elemento (pop), observar el elemento superior (peek), verificar si la pila está vacía y liberar la pila.
stack.c: Implementa tu pila genérica:
- create_stack — asigna un Stack en el heap, asigna el arreglo de elementos con la capacidad dada, inicializa top en 0 y devuelve el puntero.
- push — añade un elemento a la parte superior si hay espacio (cuando top es menor que la capacidad).
- pop — elimina y devuelve el elemento superior, o devuelve NULL si la pila está vacía.
- peek — devuelve el elemento superior sin eliminarlo, o NULL si está vacía.
- is_empty — devuelve 1 si la pila no tiene elementos, 0 en caso contrario.
- free_stack — libera primero el arreglo de elementos y luego la propia estructura Stack.
main.c: Lee el número de operaciones a realizar. Luego, para cada operación, lee un comando: push seguido de un valor entero, pop, o peek. Crea una pila con capacidad 10. Para push, asigna un entero en el heap y añade su puntero. Para pop, recupera el elemento, imprime su valor y libera el entero. Para peek, imprime el valor sin eliminarlo. Si se llama a pop o peek en una pila vacía, imprime empty. Después de todas las operaciones, libera cualquier elemento restante y la pila.

Tu programa recibirá:

El número de operaciones
Cada operación en una línea separada (push X, pop, o peek)

Ejemplo de salida cuando las entradas son 5, luego push 10, push 20, peek, pop, pop:

20
20
10

Ejemplo de salida cuando las entradas son 3, luego pop, push 42, peek:

empty
42

Ejemplo de salida cuando las entradas son 4, luego push 5, push 15, pop, pop:

15
5

Recuerda que tu pila almacena punteros void*; quien llama a la función es responsable de asignar y liberar los datos reales. Al hacer pop, convierte el void* devuelto de nuevo a int* para acceder al valor. Usa strcmp de <string.h> para comparar las cadenas de comando.

Pruébalo tú mismo

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "stack.h"

int main() {
    int n;
    scanf("%d", &n);
    
    // TODO: Crear una pila con capacidad 10
    
    // TODO: Procesar cada operación
    for (int i = 0; i < n; i++) {
        char command[10];
        scanf("%s", command);
        
        if (strcmp(command, "push") == 0) {
            int value;
            scanf("%d", &value);
            // TODO: Asignar un entero en el heap y hacer push de su puntero
        }
        else if (strcmp(command, "pop") == 0) {
            // TODO: Hacer pop del elemento
            // - Si no es NULL, imprimir el valor y liberar el entero
            // - Si es NULL (pila vacía), imprimir "empty"
        }
        else if (strcmp(command, "peek") == 0) {
            // TODO: Mirar (peek) el elemento superior
            // - Si no es NULL, imprimir el valor (no eliminar ni liberar)
            // - Si es NULL (pila vacía), imprimir "empty"
        }
    }
    
    // TODO: Liberar cualquier elemento restante en la pila
    // TODO: Liberar la pila misma
    
    return 0;
}