Cuestión 1 — Traza de memoria paso a paso

Conviene distinguir dos zonas de memoria:

• Pila (stack): la variable local Cola c de main, inicializada a { cabeza = NULL, cola = NULL }. Contiene dos punteros.
• Montón (heap): los nodos creados con malloc, que llamaremos N1, N2, N3.

Estado inicial (antes de encolar nada):

Tras encolar(&c, 101, 3) → se reserva N1. Como c->cabeza == NULL, se ejecuta la rama then: c->cabeza = N1. Después, incondicionalmente, c->cola = N1.

Tras encolar(&c, 102, 12) → se reserva N2. Ahora c->cabeza != NULL, así que se ejecuta la rama else: c->cola->sig = N2 (es decir, N1.sig = N2). Luego c->cola = N2.

Tras encolar(&c, 103, 1) → se reserva N3. Rama else: c->cola->sig = N3 (N2.sig = N3). Luego c->cola = N3.

Primer desencolar(&c) → n = c->cabeza (= N1); id = 101; c->cabeza = n->sig (= N2); free(N1); devuelve 101. Imprime Atiende 101.

Segundo desencolar(&c) → n = c->cabeza (= N2); id = 102; c->cabeza = n->sig (= N3); free(N2); devuelve 102. Imprime Atiende 102.

Salida exacta por consola, en este orden:

Atiende 101
Atiende 102

Justificación FIFO frente a LIFO. Los nodos entran siempre por la cola (c->cola->sig = n; c->cola = n) y salen siempre por la cabeza (c->cabeza = n->sig). Como se inserta por un extremo y se extrae por el opuesto, el primero que entró (101) es el primero que sale: disciplina FIFO (First In, First Out). Si insertásemos y extrajésemos por el mismo extremo (la cabeza), tendríamos una pila LIFO, y el primero en salir sería 103. El uso de dos punteros (cabeza y cola) es lo que permite que tanto la inserción por el final como la extracción por el principio sean O(1).

Cuestión 2 — Fugas de memoria

Sí queda memoria sin liberar. Se han hecho 3 llamadas a malloc (N1, N2, N3) y solo 2 a free (en los dos desencolar). Por tanto, al terminar main queda 1 nodo vivo: N3 (id=103, paginas=1), apuntado por c.cabeza y c.cola. Cuando main retorna, esos punteros desaparecen de la pila pero el bloque de N3 permanece reservado en el heap sin nadie que lo referencie: es una fuga de memoria (un detector como Valgrind reportaría "1 block still reachable / definitely lost").

Nota: en este programa concreto el SO recupera toda la memoria al terminar el proceso, pero en un servicio de larga duración (como el gestor de cola del taller) las fugas acumuladas agotan la memoria. Por eso hay que liberar explícitamente.

Función para vaciar la cola liberando todos los nodos restantes:

void vaciar(Cola *c) {
    Nodo *actual = c->cabeza;
    while (actual != NULL) {
        Nodo *siguiente = actual->sig;  /* (1) guardar sig ANTES de free */
        free(actual);                    /* (2) liberar el nodo actual   */
        actual = siguiente;              /* (3) avanzar con el guardado  */
    }
    c->cabeza = NULL;                    /* estado coherente */
    c->cola   = NULL;
}

Orden correcto y por qué. La clave es la línea (1): hay que copiar actual->sig en una variable temporal antes de hacer free(actual). Si invirtiéramos el orden —free(actual); actual = actual->sig;— estaríamos leyendo el campo sig de un bloque ya liberado, lo que es un use-after-free (comportamiento indefinido: el bloque podría haber sido reutilizado, dando un puntero basura y un fallo de segmentación). Al guardar primero siguiente, el free posterior no nos impide avanzar. Finalmente se ponen cabeza y cola a NULL para que la cola quede en un estado consistente y reutilizable (vacía), evitando punteros colgantes.

Cuestión 3 — Detección de errores y versión defensiva

(a) desencolar sobre una cola vacía. Si c->cabeza == NULL, la línea Nodo *n = c->cabeza; asigna NULL a n, y a continuación int id = n->id; (línea 38 del código original) desreferencia un puntero nulo. Esto es un comportamiento indefinido; en la práctica produce un fallo de segmentación (segmentation fault / null pointer dereference). El error se manifiesta, por tanto, en la línea del acceso n->id.

(b) encolar no comprueba malloc. Si la memoria está agotada, malloc devuelve NULL y la siguiente línea n->id = id; vuelve a desreferenciar un puntero nulo → fallo de segmentación.

Efecto colateral sobre cola al desencolar el último nodo. Cuando se extrae el único nodo restante, c->cabeza pasa correctamente a NULL (porque n->sig == NULL), pero c->cola se queda apuntando al nodo recién liberado (puntero colgante / dangling pointer). En el siguiente encolar, la condición c->cabeza == NULL sí enrutaría por la rama then y la cosa se "arreglaría", pero dejar cola apuntando a memoria liberada es incorrecto y peligroso. Hay que ponerla también a NULL.

Versión defensiva de ambas funciones:

/* Devuelve 0 si reservó bien, -1 si no hubo memoria. */
int encolar(Cola *c, int id, int paginas) {
    Nodo *n = malloc(sizeof(Nodo));
    if (n == NULL) {                 /* (b) malloc puede fallar */
        return -1;                   /* no se modifica la cola  */
    }
    n->id = id;
    n->paginas = paginas;
    n->sig = NULL;

    if (c->cabeza == NULL)
        c->cabeza = n;
    else
        c->cola->sig = n;
    c->cola = n;
    return 0;
}

/* Devuelve el id atendido, o -1 (centinela) si la cola está vacía. */
int desencolar(Cola *c) {
    if (c->cabeza == NULL)           /* (a) no desreferenciar NULL */
        return -1;

    Nodo *n = c->cabeza;
    int id = n->id;
    c->cabeza = n->sig;

    if (c->cabeza == NULL)           /* se sacó el último nodo:    */
        c->cola = NULL;              /* corrige el puntero colgante */

    free(n);
    return id;
}

Observaciones de justificación:

• En encolar se comprueba malloc antes de tocar el nuevo nodo y antes de enlazarlo, de modo que un fallo de reserva deja la cola intacta (fuerte garantía de no corrupción).
• En desencolar, el valor centinela -1 es válido aquí porque los identificadores de trabajo son positivos; en un diseño más estricto se devolvería el id por parámetro de salida y un código de error (int desencolar(Cola *c, int *id_out)).
• La guarda if (c->cabeza == NULL) c->cola = NULL; se coloca antes del free (da igual respecto al free de n, porque no toca a n), garantizando que la cola vacía queda con ambos punteros a NULL.

Cuestión 4 — Variante con puntero doble (Nodo **)

void encolar(Cola *c, int id, int paginas) {
    Nodo *n = malloc(sizeof(Nodo));
    if (n == NULL) return;
    n->id = id;
    n->paginas = paginas;
    n->sig = NULL;

    /* pp apunta a la "casilla" donde debe escribirse la dirección de n */
    Nodo **pp = (c->cabeza == NULL) ? &c->cabeza : &c->cola->sig;
    *pp = n;
    c->cola = n;
}

Si se quiere eliminar también ese ternario y razonar con un puntero doble que recorra hasta el final (variante sin campo cola cacheado):

void encolar_sin_cola(Nodo **cabeza, int id, int paginas) {
    Nodo *n = malloc(sizeof(Nodo));
    if (n == NULL) return;
    n->id = id; n->paginas = paginas; n->sig = NULL;

    Nodo **pp = cabeza;          /* apunta a la casilla cabeza        */
    while (*pp != NULL)          /* avanza mientras la casilla apunte  */
        pp = &(*pp)->sig;        /* a un nodo: pasa a su casilla sig   */
    *pp = n;                     /* escribe en la primera casilla NULL */
}

Qué apunta el doble puntero en cada caso. pp no apunta a un nodo, sino a la casilla de memoria (el campo puntero) que hay que actualizar:

• Si la cola está vacía, la casilla a modificar es c->cabeza, por lo que pp = &c->cabeza y *pp = n escribe el nodo en cabeza.
• Si la cola no está vacía, la casilla a modificar es el campo sig del último nodo, por lo que pp = &c->cola->sig.

Por qué simplifica. El if/else del original existía solo porque "la casilla destino" cambia según haya o no nodos: en un caso se escribe en cabeza (un campo de la estructura Cola) y en otro en sig (un campo del último Nodo). Al trabajar con la dirección de esa casilla en lugar de con su contenido, ambos casos se unifican en una sola asignación *pp = n. El doble puntero captura la idea de "el sitio donde colgar el nuevo nodo", elimina la duplicación de ramas y reduce la posibilidad de olvidar uno de los dos casos.

Cuestión 5 — ¿Por qué estructura enlazada dinámica y no array estático?

Razonamiento. El enunciado dice que se desconoce a priori cuántos trabajos habrá, condición que descarta un array estático: habría que sobredimensionarlo (desperdiciando memoria si llegan pocos trabajos) y aun así existiría un techo a partir del cual se produciría un desbordamiento del array, con pérdida de trabajos o, peor, escritura fuera de límites y corrupción de memoria.

La cola enlazada ofrece tanto encolar como desencolar en O(1) constante —gracias a mantener los dos punteros cabeza y cola— sin necesidad de desplazar elementos, que es justo lo que penaliza a un array simple en la extracción por el frente (O(n)). Además ajusta el consumo de memoria a la carga real (crece y decrece con los trabajos), a costa de un pequeño sobrecoste de un puntero por nodo y de las llamadas a malloc/free. Para una cola de impresión de tamaño impredecible y vida prolongada, este equilibrio (escalabilidad + no desbordamiento) es claramente preferible. Si en cambio el número máximo de trabajos fuera conocido y pequeño, y primara la velocidad/localidad de caché, un buffer circular sobre array fijo sería una alternativa válida que también logra O(1) en ambas operaciones sin desplazamientos.