Visualizador Web de Estructuras de Datos

Pila

Descripcion del TAD

Estructura LIFO (Last In, First Out): el ultimo nodo en entrar queda en el TOPE y es el primero en salir. En la simulacion observa como se crea el nodo auxiliar, se enlaza al tope actual y luego se reasigna el puntero principal de la pila. La Pila (LIFO) modela escenarios donde el ultimo elemento agregado es el primero en salir. En C se implementa con nodos enlazados y un puntero al tope; por eso la simulacion enfatiza creacion de auxiliares, reasignacion de punteros y liberacion de memoria.

Errores frecuentes

• Confundir TOP con el fondo
• Usar aux después de free

Controles de ejecucion paso a paso

• Checkbox Interpretar codigo paso a paso: activado muestra toda la traza; desactivado aplica solo el resultado final.
• Botones de ejecucion: Reproducir y Reiniciar.
• Navegacion por traza: Anterior paso y Siguiente paso.
• Velocidad de simulacion: slider de -2x a +2x (0.00x = 1.00x real).
• En modo rapido (checkbox desactivado), el resultado visual final debe coincidir con el ultimo estado de la traza interpretada.
• Al llegar al ultimo paso, Siguiente paso se bloquea hasta cambiar entradas/operacion; Anterior paso se habilita solo cuando ya avanzaste.

Operaciones soportadas

• pila_apilar
• pila_desapilar
• pila_destruir

Operaciones pendientes / restricciones

No hay operaciones pendientes para esta estructura en esta fase.

Estructura del TAD en C

typedef struct NodoPila {
    int nro;                  
    struct NodoPila *sgte;    
} *ptrPila;

Metodos del TAD en C

Codigo C: apilar

Reserva un nodo auxiliar, copia el valor, enlaza el nodo al tope actual y actualiza el puntero principal.

/**
 * @brief Apila un nuevo valor en la pila.
 * @param p Puntero a la pila.
 * @param valor Valor entero que se apilará.
 */
void pila_apilar(ptrPila *p, int valor) {
    if (p == NULL) {
        printf("Error: pila no inicializada.\n");
        return;
    }

    ptrPila aux = (ptrPila) malloc(sizeof(struct NodoPila));
    if (aux == NULL) {
        printf("Error: No se pudo asignar memoria.\n");
        return;
    }
    aux->nro = valor;
    aux->sgte = *p;
    *p = aux;
}

Codigo C: desapilar

Valida pila no vacia, extrae el nodo del tope, reasigna el tope al siguiente y libera memoria del nodo removido.

/**
 * @brief Desapila y devuelve el valor en la cima de la pila.
 * @param p Puntero a la pila.
 * @return int Valor desapilado.
 */
int pila_desapilar(ptrPila *p) {
    if (p == NULL || *p == NULL) {
        printf("Pila vacía. No se puede desapilar.\n");
        return -1;  // Valor de error
    }

    ptrPila aux = *p;
    int num = aux->nro;
    *p = aux->sgte;
    free(aux);
    return num;
}

Codigo C: limpiar

Recorre la estructura liberando todos los nodos y deja el puntero raiz en estado nulo para reinicio seguro.

/**
 * @brief Elimina todos los elementos de la pila.
 * @param p Puntero a la pila.
 */
void pila_destruir(ptrPila *p) {
    ptrPila aux;
    if (p == NULL) {
        return;
    }

    while (*p != NULL) {
        aux = *p;
        *p = aux->sgte;
        free(aux);
    }
}

Codigo C: cima

Este metodo del TAD Pila debe interpretarse respetando condicionales, ciclos, returns y actualizacion del estado visual segun el flujo real del codigo C.

int pila_cima(ptrPila p) {
    return p == NULL ? -1 : p->nro;
}

Ir a la visualizacion