Pila genérica

Parte de la sección Programación Orientada a Objetos del Journey de C de Coddy. Lección 60 de 61.

Desafío

Fácil

Una pila es una estructura de datos fundamental que sigue el principio de último en entrar, primero en salir (LIFO): el último elemento añadido es el primero en retirarse. Piensa en una pila de platos: añades por arriba y retiras por arriba.

Construyamos una pila genérica: una estructura de datos versátil que puede almacenar cualquier tipo de datos mediante punteros void*. Tu pila seguirá el principio de último en entrar, primero en salir, 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 de la cima (siguiente posición libre) y un int para la capacidad. Declara los prototipos de las funciones para crear una pila (recibe una capacidad), insertar un elemento, extraer un elemento, consultar el elemento de la cima, comprobar si la pila está vacía y liberar la pila.
stack.c: Implementa tu pila genérica:
- create_stack: asigna una Stack en el montón, asigna el arreglo de elementos con la capacidad indicada, inicializa top en 0 y devuelve el puntero
- push: añade un elemento a la cima si hay espacio (cuando top es menor que capacity)
- pop: extrae y devuelve el elemento de la cima, o devuelve NULL si la pila está vacía
- peek: devuelve el elemento de la cima sin extraerlo, o NULL si está vacía
- is_empty: devuelve 1 si la pila no contiene elementos, y 0 en caso contrario
- free_stack: libera primero el arreglo de elementos y después la propia estructura Stack
main.c: Lee el número de operaciones que se realizarán. Después, 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 montón e inserta su puntero. Para pop, recupera el elemento, muestra su valor y libera el entero. Para peek, muestra el valor sin extraerlo. Si se llama a pop o peek cuando la pila está vacía, muestra empty. Después de todas las operaciones, libera los elementos restantes y la pila.

Tu programa recibirá:

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

Salida de ejemplo cuando las entradas son 5, después push 10, push 20, peek, pop, pop:

20
20
10

Salida de ejemplo cuando las entradas son 3, después pop, push 42, peek:

empty
42

Salida de ejemplo cuando las entradas son 4, después push 5, push 15, pop, pop:

15
5

Recuerda que tu pila almacena punteros void*: el llamador es responsable de asignar y liberar los datos reales. Al extraer, convierte el void* devuelto nuevamente a int* para acceder al valor. Usa strcmp de <string.h> para comparar las cadenas de los comandos.

Pruébalo tú mismo

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

int main() {
    int n;
    scanf("%d", &n);
    
    // TODO: Crea una pila con capacidad 10
    
    // TODO: Procesa 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: Asigna un entero en el heap y apila su puntero
        }
        else if (strcmp(command, "pop") == 0) {
            // TODO: Desapila el elemento
            // - Si no es NULL, imprime el valor y libera el entero
            // - Si es NULL (pila vacía), imprime "empty"
        }
        else if (strcmp(command, "peek") == 0) {
            // TODO: Consulta el elemento de la cima
            // - Si no es NULL, imprime el valor (no lo elimines ni lo liberes)
            // - Si es NULL (pila vacía), imprime "empty"
        }
    }
    
    // TODO: Libera los elementos restantes de la pila
    // TODO: Libera la pila en sí
    
    return 0;
}