LeetCode //C - 59. Matriz Espiral II

59. Matriz Espiral II

Dado un entero positivo n , genere una matriz nxn llena de elementos del 1 al n 2 n^2${norte}^2$ en orden de espiral.
 

Ejemplo 1:

Entrada: n = 3
Salida: [[1,2,3],[8,9,4],[7,6,5]]

Ejemplo 2:

Entrada: n = 1
Salida: [[1]]

Restricciones:

• 1 <= norte <= 20

De: LeetCode
Enlace: 59. Matriz Espiral II

---

Solución:

Ideas:

1. Inicializar variables:

• Inicialice la matriz 2D (la matriz) que se devolverá.
• Inicialice punteros para el número de filas y el tamaño de cada fila que se devolverá.
• Inicialice las variables para los límites superior, inferior, izquierdo y derecho de la "capa" actual de la espiral.
• Inicialice una variable val en 1 para que el siguiente valor se inserte en la matriz.

2. Repita hasta que termine:

• Bucle mientras arriba <= abajo e izquierda <= derecha.

3. Valores de relleno:

• Fila superior: complete la fila superior de izquierda a derecha y luego incremente el límite superior.
• Columna derecha: llene la columna derecha de arriba a abajo y luego disminuya el límite derecho.
• Fila inferior: complete la fila inferior de derecha a izquierda (si arriba <= abajo) y luego disminuya el límite inferior.
• Columna izquierda: complete la columna izquierda de abajo hacia arriba (si izquierda <= derecha) y luego incremente el límite izquierdo.

4. Incrementar valor: después de llenar cada celda, incremente el valor de val para la siguiente celda.

5. Devolver la matriz llena: Devuelve la matriz 2D una vez que esté completamente llena.

Código:

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** generateMatrix(int n, int* returnSize, int** returnColumnSizes){
    
    
    // Initialize the output array and sizes
    int** output = (int**)malloc(n * sizeof(int*));
    *returnColumnSizes = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; ++i) {
    
    
        output[i] = (int*)malloc(n * sizeof(int));
        (*returnColumnSizes)[i] = n;
    }
    *returnSize = n;

    // Initialize variables for boundaries and direction
    int top = 0, bottom = n - 1, left = 0, right = n - 1;
    int val = 1;

    // Loop through the matrix to fill values
    while (top <= bottom && left <= right) {
    
    
        // Fill top row
        for (int i = left; i <= right; ++i) {
    
    
            output[top][i] = val++;
        }
        ++top;

        // Fill right column
        for (int i = top; i <= bottom; ++i) {
    
    
            output[i][right] = val++;
        }
        --right;

        // Fill bottom row
        if (top <= bottom) {
    
    
            for (int i = right; i >= left; --i) {
    
    
                output[bottom][i] = val++;
            }
            --bottom;
        }

        // Fill left column
        if (left <= right) {
    
    
            for (int i = bottom; i >= top; --i) {
    
    
                output[i][left] = val++;
            }
            ++left;
        }
    }

    return output;
}