Crear matrices bidimensionales en C

Introducción

En este laboratorio, aprenderás cómo crear y manipular matrices bidimensionales en C. Comenzarás declarando matrices bidimensionales y luego explorarás varios métodos para inicializarlas. A continuación, aprenderás cómo acceder y manipular los elementos de las matrices. Finalmente, aplicarás tus conocimientos para calcular el promedio de notas de dos materias y mejorar la funcionalidad de las matrices bidimensionales. Este laboratorio brinda una comprensión integral de trabajar con matrices bidimensionales en el lenguaje de programación C.

Declarar matrices bidimensionales

En este paso, aprenderás cómo declarar matrices bidimensionales en C, que son esencialmente matrices de matrices que te permiten almacenar datos en una estructura similar a una cuadrícula con filas y columnas.

Comencemos creando un nuevo archivo C para demostrar la declaración de matrices bidimensionales:

touch ~/project/two_dimensional_arrays.c

Ahora, escribamos nuestra primera declaración de matriz bidimensional:

#include <stdio.h>

int main() {
    // Declare a 3x4 integer two-dimensional array
    int grades[3][4];

    return 0;
}

En este ejemplo, grades es una matriz bidimensional con 3 filas y 4 columnas. Esto significa que puede almacenar un total de 12 valores enteros (3 × 4 = 12).

Exploremos diferentes formas de declarar matrices bidimensionales, agregando el siguiente código al archivo:

// Method 1: Declaration with initialization
int matrix[2][3] = {
    {1, 2, 3},   // First row
    {4, 5, 6}    // Second row
};

// Method 2: Partial initialization
int scores[3][3] = {
    {10, 20, 30},
    {40, 50}     // Remaining elements will be zero
};

// Method 3: Flattened initialization
int simple_matrix[2][3] = {1, 2, 3, 4, 5, 6};

Compila y ejecuta el programa para verificar:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

La salida de ejemplo será una ejecución de programa vacía ya que no hemos agregado ninguna declaración de impresión.

Puntos clave sobre la declaración de matrices bidimensionales:

• El primer corchete representa las filas
• El segundo corchete representa las columnas
• Puedes inicializar parcial o completamente
• Los elementos no inicializados se establecen automáticamente en cero
• Total de elementos = filas × columnas

Inicializar matrices bidimensionales

En este paso, aprenderás varios métodos para inicializar matrices bidimensionales en C, basándote en las habilidades de declaración del paso anterior.

Modifiquemos el archivo anterior para explorar diferentes técnicas de inicialización.

Ahora, reemplaza el código existente con los siguientes métodos de inicialización:

#include <stdio.h>

int main() {
    // Method 1: Complete initialization
    int scores[3][4] = {
        {85, 92, 78, 90},    // First row
        {76, 88, 95, 82},    // Second row
        {63, 71, 89, 93}     // Third row
    };

    // Method 2: Partial initialization
    int temperatures[2][3] = {
        {25, 30, 22},        // First row
        {28}                 // Partial second row
    };

    // Method 3: Flattened initialization
    int matrix[2][3] = {1, 2, 3, 4, 5, 6};

    // Method 4: Initialize all elements to zero
    int zeros[3][3] = {0};

    // Print the first method to demonstrate
    printf("Student Scores:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d ", scores[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Compila y ejecuta el programa:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Salida de ejemplo:

Student Scores:
85 92 78 90
76 88 95 82
63 71 89 93

Métodos de inicialización principales:

1. Inicialización completa: Especifica valores para cada fila
2. Inicialización parcial: Los elementos no especificados se establecen en cero
3. Inicialización aplanada: Los valores se llenan fila por fila
4. Inicialización a cero: Todos los elementos se establecen en cero

Puntos importantes:

• Puedes inicializar parcialmente las matrices
• Los elementos no especificados se establecen automáticamente en cero
• El número total de inicializadores no puede exceder el tamaño de la matriz
• Las llaves anidadas ayudan a aclarar la inicialización por filas

Acceder a elementos de matrices bidimensionales

En este paso, aprenderás cómo acceder a elementos individuales en una matriz bidimensional utilizando índices y bucles anidados en C.

Actualicemos nuestro archivo anterior para demostrar el acceso a elementos.

Agrega el siguiente código para explorar diferentes formas de acceder a los elementos de la matriz:

#include <stdio.h>

int main() {
    // Create a 3x4 student grades array
    int grades[3][4] = {
        {85, 92, 78, 90},    // First student's grades
        {76, 88, 95, 82},    // Second student's grades
        {63, 71, 89, 93}     // Third student's grades
    };

    // Method 1: Direct element access
    printf("First student's first grade: %d\n", grades[0][0]);
    printf("Second student's third grade: %d\n", grades[1][2]);

    // Method 2: Accessing elements using nested loops
    printf("\nAll grades using nested loops:\n");
    for (int student = 0; student < 3; student++) {
        for (int subject = 0; subject < 4; subject++) {
            printf("Student %d, Subject %d: %d\n",
                   student + 1, subject + 1, grades[student][subject]);
        }
    }

    // Method 3: Modifying array elements
    grades[2][3] = 95;  // Update last grade of third student
    printf("\nUpdated third student's last grade: %d\n", grades[2][3]);

    return 0;
}

Compila y ejecuta el programa:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Salida de ejemplo:

First student's first grade: 85
Second student's third grade: 95

All grades using nested loops:
Student 1, Subject 1: 85
Student 1, Subject 2: 92
Student 1, Subject 3: 78
Student 1, Subject 4: 90
Student 2, Subject 1: 76
Student 2, Subject 2: 88
Student 2, Subject 3: 95
Student 2, Subject 4: 82
Student 3, Subject 1: 63
Student 3, Subject 2: 71
Student 3, Subject 3: 89
Student 3, Subject 4: 95

Updated third student's last grade: 95

Puntos clave sobre el acceso a elementos de una matriz bidimensional:

• Utiliza dos índices: array[row][column]
• El primer índice representa la fila (vertical)
• El segundo índice representa la columna (horizontal)
• La indexación comienza en 0
• Los bucles anidados son útiles para recorrer matrices enteras
• Puedes leer y modificar directamente elementos individuales

Calcular el promedio de notas de dos materias

En este paso, aprenderás cómo utilizar matrices bidimensionales para calcular el promedio de notas de múltiples estudiantes en diferentes materias.

Actualicemos nuestro archivo anterior para calcular los promedios de las materias.

Agrega el siguiente código para calcular y mostrar los promedios de notas:

#include <stdio.h>

#define STUDENTS 5
#define SUBJECTS 3

int main() {
    // Create a two-dimensional array for student marks
    int marks[STUDENTS][SUBJECTS] = {
        {85, 92, 78},
        {76, 88, 95},
        {63, 71, 89},
        {90, 84, 77},
        {82, 79, 91}
    };

    // Arrays to store subject averages
    float subject_averages[SUBJECTS];

    // Compute average for each subject
    for (int subject = 0; subject < SUBJECTS; subject++) {
        int subject_total = 0;

        // Sum marks for current subject
        for (int student = 0; student < STUDENTS; student++) {
            subject_total += marks[student][subject];
        }

        // Calculate average
        subject_averages[subject] = (float)subject_total / STUDENTS;
    }

    // Display subject averages
    printf("Subject Averages:\n");
    for (int subject = 0; subject < SUBJECTS; subject++) {
        printf("Subject %d: %.2f\n", subject + 1, subject_averages[subject]);
    }

    // Bonus: Find highest and lowest subject average
    float highest_avg = subject_averages[0];
    float lowest_avg = subject_averages[0];
    int highest_subject = 0;
    int lowest_subject = 0;

    for (int subject = 1; subject < SUBJECTS; subject++) {
        if (subject_averages[subject] > highest_avg) {
            highest_avg = subject_averages[subject];
            highest_subject = subject;
        }
        if (subject_averages[subject] < lowest_avg) {
            lowest_avg = subject_averages[subject];
            lowest_subject = subject;
        }
    }

    printf("\nHighest Average: Subject %d (%.2f)\n",
           highest_subject + 1, highest_avg);
    printf("Lowest Average: Subject %d (%.2f)\n",
           lowest_subject + 1, lowest_avg);

    return 0;
}

Compila y ejecuta el programa:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Salida de ejemplo:

Subject Averages:
Subject 1: 79.20
Subject 2: 82.80
Subject 3: 86.00

Highest Average: Subject 3 (86.00)
Lowest Average: Subject 1 (79.20)

Conceptos clave demostrados:

• Uso de bucles anidados para procesar matrices bidimensionales
• Cálculo de promedios a lo largo de filas y columnas
• Búsqueda de los promedios más altos y más bajos
• Conversión de tipos para calcular promedios en punto flotante
• Definición de constantes para las dimensiones de la matriz

Mejorar la funcionalidad de matrices bidimensionales

En este último paso, aprenderás técnicas avanzadas para mejorar la funcionalidad de matrices bidimensionales, incluyendo el paso de matrices a funciones, la asignación dinámica de memoria y la creación de operaciones de matriz más complejas.

Actualicemos nuestro archivo anterior para demostrar estos conceptos avanzados.

Reemplaza el código anterior con este ejemplo completo:

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

#define ROWS 3
#define COLS 4

// Function to print a two-dimensional array
void printArray(int arr[ROWS][COLS]) {
    printf("Array Contents:\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d ", arr[i][j]);
        }
        printf("\n");
    }
}

// Function to transpose a two-dimensional array
void transposeArray(int original[ROWS][COLS], int transposed[COLS][ROWS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            transposed[j][i] = original[i][j];
        }
    }
}

int main() {
    // Static two-dimensional array
    int matrix[ROWS][COLS] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    // Print original array
    printf("Original Array:\n");
    printArray(matrix);

    // Transpose the array
    int transposed[COLS][ROWS];
    transposeArray(matrix, transposed);

    // Print transposed array
    printf("\nTransposed Array:\n");
    for (int i = 0; i < COLS; i++) {
        for (int j = 0; j < ROWS; j++) {
            printf("%4d ", transposed[i][j]);
        }
        printf("\n");
    }

    // Dynamic memory allocation for 2D array
    int **dynamicMatrix;
    dynamicMatrix = (int **)malloc(ROWS * sizeof(int *));
    for (int i = 0; i < ROWS; i++) {
        dynamicMatrix[i] = (int *)malloc(COLS * sizeof(int));
    }

    // Initialize dynamic matrix
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            dynamicMatrix[i][j] = i * COLS + j + 1;
        }
    }

    // Print dynamic matrix
    printf("\nDynamic Matrix:\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d ", dynamicMatrix[i][j]);
        }
        printf("\n");
    }

    // Free dynamically allocated memory
    for (int i = 0; i < ROWS; i++) {
        free(dynamicMatrix[i]);
    }
    free(dynamicMatrix);

    return 0;
}

Compila y ejecuta el programa:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Salida de ejemplo:

Original Array:
   1   2   3   4
   5   6   7   8
   9  10  11  12

Transposed Array:
   1   5   9
   2   6  10
   3   7  11
   4   8  12

Dynamic Matrix:
   1   2   3   4
   5   6   7   8
   9  10  11  12

Conceptos avanzados clave demostrados:

• Paso de matrices bidimensionales a funciones
• Transposición de matrices
• Asignación dinámica de memoria para matrices bidimensionales
• Gestión de memoria con malloc() y free()
• Técnicas flexibles de manipulación de matrices

Resumen

En este laboratorio, aprendiste cómo declarar matrices bidimensionales en C, que son matrices de matrices que te permiten almacenar datos en una estructura similar a una cuadrícula con filas y columnas. Exploraste diferentes métodos de declaración e inicialización de matrices bidimensionales, incluyendo la inicialización completa, la inicialización parcial y la inicialización aplanada. También aprendiste que los elementos no inicializados se establecen automáticamente en cero, y que el número total de elementos en una matriz bidimensional está determinado por el producto del número de filas y columnas.

Basándote en las habilidades de declaración, luego aprendiste varios métodos para inicializar matrices bidimensionales en C, incluyendo la asignación de valores fila por fila, columna por columna o utilizando un enfoque aplanado. También exploraste cómo acceder a elementos individuales dentro de la matriz bidimensional utilizando índices de fila y columna.