Ejercicio resuelto: matrices dinámicas con malloc y free en C

La solución separa las responsabilidades en funciones pequeñas: una crea la matriz y gestiona los fallos parciales, otra la libera, otra produce la versión rotada y otra elimina filas vacías. Así cada malloc tiene un free fácil de localizar, que es lo primero que un corrector busca en este tipo de ejercicio.

La matriz original se libera en cuanto se ha construido la rotada, porque ya no se necesita. Al final solo queda por liberar la matriz rotada y compactada, con su número real de filas.

#include <stdio.h>
#include <stdlib.h>

/* Libera las 'filas' primeras filas y el vector de punteros. */
static void liberar_matriz(int **m, int filas)
{
    if (m == NULL) {
        return;
    }
    for (int i = 0; i < filas; i++) {
        free(m[i]);
    }
    free(m);
}

/* Reserva una matriz filas x cols. Si algo falla, no deja memoria perdida. */
static int **crear_matriz(int filas, int cols)
{
    int **m = malloc((size_t)filas * sizeof *m);
    if (m == NULL) {
        return NULL;
    }
    for (int i = 0; i < filas; i++) {
        m[i] = malloc((size_t)cols * sizeof *m[i]);
        if (m[i] == NULL) {
            liberar_matriz(m, i); /* solo las filas 0..i-1 existen */
            return NULL;
        }
    }
    return m;
}

/* Devuelve una matriz nueva de c filas y f columnas: m rotada 90 grados horario. */
static int **rotar_derecha(int **m, int f, int c)
{
    int **r = crear_matriz(c, f);
    if (r == NULL) {
        return NULL;
    }
    for (int i = 0; i < f; i++) {
        for (int j = 0; j < c; j++) {
            r[j][f - 1 - i] = m[i][j];
        }
    }
    return r;
}

static int fila_vacia(const int *fila, int n)
{
    for (int k = 0; k < n; k++) {
        if (fila[k] != 0) {
            return 0;
        }
    }
    return 1;
}

/* Libera las filas de ceros y sube los punteros restantes. Devuelve las filas que quedan. */
static int compactar(int **m, int filas, int cols)
{
    int k = 0;
    for (int i = 0; i < filas; i++) {
        if (fila_vacia(m[i], cols)) {
            free(m[i]);
        } else {
            m[k] = m[i];
            k++;
        }
    }
    return k;
}

static void imprimir_matriz(int **m, int filas, int cols)
{
    for (int i = 0; i < filas; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%s%d", j > 0 ? " " : "", m[i][j]);
        }
        putchar('\n');
    }
}

int main(void)
{
    int f, c;
    if (scanf("%d %d", &f, &c) != 2 || f < 0 || c < 0) {
        printf("ERROR\n");
        return EXIT_FAILURE;
    }
    if (f == 0 || c == 0) {
        printf("VACIA\n");
        return EXIT_SUCCESS;
    }

    int **m = crear_matriz(f, c);
    if (m == NULL) {
        fprintf(stderr, "Sin memoria\n");
        return EXIT_FAILURE;
    }
    for (int i = 0; i < f; i++) {
        for (int j = 0; j < c; j++) {
            if (scanf("%d", &m[i][j]) != 1) {
                liberar_matriz(m, f);
                printf("ERROR\n");
                return EXIT_FAILURE;
            }
        }
    }

    int **r = rotar_derecha(m, f, c);
    liberar_matriz(m, f); /* la original ya no hace falta */
    if (r == NULL) {
        fprintf(stderr, "Sin memoria\n");
        return EXIT_FAILURE;
    }

    printf("ROTADA %d x %d\n", c, f);
    imprimir_matriz(r, c, f);

    int k = compactar(r, c, f);
    printf("COMPACTADA %d x %d\n", k, f);
    imprimir_matriz(r, k, f);

    liberar_matriz(r, k); /* las filas vacias ya se liberaron en compactar */
    return EXIT_SUCCESS;
}

Reserva. crear_matriz hace primero un malloc para el vector de filas punteros y después uno por fila, de cols enteros. La expresión sizeof *m evita repetir el tipo: si mañana la matriz es de double, la reserva sigue siendo correcta. El detalle importante es el fallo parcial. Si falla la fila i, se llama a liberar_matriz(m, i), que libera exactamente las i filas ya creadas y el vector. Liberar filas filas sería un error, porque se haría free sobre punteros sin inicializar.

Rotación. En rotar_derecha el elemento m[i][j] pasa a r[j][f - 1 - i]. La columna j original se convierte en la fila j de la rotada. Como el índice de columna destino es f - 1 - i, la última fila original (i = f - 1) queda a la izquierda y la primera a la derecha. En el caso de ejemplo, la columna 0 original contiene 5, 1 y 7 de arriba abajo, y por eso la primera fila rotada es 7 1 5. La matriz resultante tiene c filas y f columnas, y por eso se reserva con crear_matriz(c, f) y no al revés.

Compactación. compactar usa dos índices. i recorre todas las filas y k marca el siguiente hueco libre. Si fila_vacia devuelve 1, se libera ese bloque con free(m[i]). Si no, su puntero se sube a m[k]. No se copia ni un solo entero, solo direcciones: es la ventaja de tener filas independientes. El orden relativo se conserva porque k nunca supera a i. En el ejemplo desaparecen las filas 1 y 3 de la rotada y quedan 7 1 5 y 4 0 2.

El criterio es «todos ceros», no «suma cero». Lo comprueba el caso de valores que se anulan: las filas -1 1 y 1 -1 suman 0 pero se conservan, y solo se elimina 0 0. En el caso de todo ceros, en cambio, desaparecen las tres filas: K vale 0 y no se imprime nada tras la cabecera.

Liberación final. Tras compactar, el vector r sigue ocupando espacio para c punteros, pero solo los k primeros apuntan a bloques vivos. Los demás son copias de punteros ya movidos o ya liberados. Por eso se llama a liberar_matriz(r, k). Si se usara c, habría dobles free, que es comportamiento indefinido. La matriz original se libera justo después de rotarla, lo que reduce el pico de memoria. Si quieres repasar cómo se pasan punteros a funciones, tienes el ejercicio de paso por valor y por referencia en C.

Casos límite. Con F o C igual a 0 el programa responde VACIA sin reservar nada. Así se evita el malloc(0), cuyo resultado depende de la implementación. Con una sola fila de 1×4, la rotada es una columna de 4×1 y la compactación elimina el único 0. Con 1×1, el elemento queda igual.