Arreglos unidimensionales

Supongamos que necesitamos almacenar la temperatura promedio de cada mes del año. En lugar de crear doce variables independientes, podemos declarar un arreglo de tipo int que contenga todos los valores:

// Almacenando temperaturas promedio mensuales
int temperaturas[12] = {12, 14, 18, 22, 27, 32, 35, 34, 29, 23, 17, 13};

La sintaxis genarel para declarar un arreglo es:

tipo nombre[tamaño] = {valores};

Algunas consideraciones importantes:

• El tipo de dato debe ser uniforme para todos los elementos del arreglo.
• El tamaño debe ser un valor entero constante.
• No es obligatorio asignar valores iniciales al momento de declarar el arreglo.

La razón por la que el tipo y tamaño deben definirse desde el inicio es que el compilador reserva un bloque contiguo de memoria en el momento de la declaración, por lo que ambos atributos son inmutables después.

Existen múltiples formas de inicializar un arreglo:

// Solo declaración, sin inicializar
int edades[8];

// Inicialización parcial: los primeros elementos reciben valor
int edades[8] = {19, 25, 30};

// Asignación por índice específico
int edades[8] = {19, 25, [4] = 300, [7] = 450};

// El tamaño se infiere automáticamente de los valores proporcionados
int edades[] = {19, 25, 30};

Los arreglos también funcionan con otros tipos de datos primtiivos:

#include <stdio.h>

int main() {
    // Arreglo de caracteres individuales
    char letras[] = {'X', 'Y', 'Z'};

    // Una cadena de texto es fundamentalmente un arreglo de caracteres
    char saludo[] = "XYZ";
}

Para acceder a elementos individuales del arreglo, se utiliza el operador de índice []. Los índices comienzan en cero, por lo que el primer elemento ocupa la posición 0:

#include <stdio.h>

int main() {
    int temperaturas[12] = {12, 14, 18, 22, 27, 32, 35, 34, 29, 23, 17, 13};
    for (int mes = 0; mes < 12; mes++) {
        int temp = temperaturas[mes];
        printf("Mes %d temperatura promedio: %d grados\n", mes + 1, temp);
    }
}

Los elementos del arreglo son mutables, pueden modificarse en cualquier momento:

#include <stdio.h>

int main() {
    int datos[] = {45, 56, 67};
    // Sobrescribir el valor del segundo elemento
    datos[1] = 100;
    printf("%d", datos[1]);
}

100

Cuando un arreglo se declara sin valores iniciales, su contenido es indeterminado. La memoria asignada puede contener residuos de operaciones anteriores, por lo que no se puede asumir que los valores serán cero:

#include <stdio.h>

int main() {
    int sinInicializar[8];
    for (int k = 0; k < 8; k++) {
        printf("%d ", sinInicializar[k]);
    }
}

18237616 0 -751023484 32711 1 0 18237562 0

Es fundamental no acceder a posiciones fuera del rango válido del arreglo. Aunque el programa compile, acceder a índices inválidos produce resultados impredecibles y puede causar comportamientos anómalos:

#include <stdio.h>

int main() {
    int valores[] = {111, 222, 333};
    // El índice 3 está fuera de rango: solo existen 0, 1 y 2
    printf("%d", valores[3]);
}

42

Arreglos multidimensionales

C permite crear arreglos con múltiples dimensiones, es decir, arreglos cuyos elementos son a su vez arreglos. Esto resulta útil cuando se necesita organizar información en forma de tabla o matriz:

// Arreglo bidimensional: cada elemento es un par de valores
int matriz[][2] = {{20, 10}, {18, 9}};

La longitud de la dimensión interna debe especificarse, mientras que la externa puede inferirse de los valores asignados.

Por ejemplo, para almacenar las temperaturas promedio mensuales durante tres años consecutivos, un arreglo bidimensional es ideal:

// Año 2020, 2021 y 2022
int temp3anios[3][12] = {
    {10, 12, 16, 20, 25, 30, 33, 32, 27, 21, 15, 11},
    {11, 13, 17, 21, 26, 31, 34, 33, 28, 22, 16, 12},
    {12, 14, 18, 22, 27, 32, 35, 34, 29, 23, 17, 13}
};

El acceso a elementos en arrgelos bidimensionales requiere dos índices:

#include <stdio.h>

int main() {
    int temp3anios[3][12] = {
        {10, 12, 16, 20, 25, 30, 33, 32, 27, 21, 15, 11},
        {11, 13, 17, 21, 26, 31, 34, 33, 28, 22, 16, 12},
        {12, 14, 18, 22, 27, 32, 35, 34, 29, 23, 17, 13}
    };
    // Temperatura del segundo mes del primer año
    printf("%d", temp3anios[0][1]);
}

12

Es posible extender este concepto a tres o más dimensiones:

int cubo[2][2][2] = {{{1, 2}, {1, 2}}, {{1, 2}, {1, 2}}};

Práctica: Ordenamiento burbuja

Dado un arreglo de números enteros desordenados, el objetivo es implementar el algoritmo de ordenamiento burbuja para organizarlos de menor a mayor.

El principio fundamental de este algoritmo consiste en:

1. Realizar múltiples pasadas sobre el arreglo.
2. En cada pasada, comparar pares adyacentes de elementos e intercambiarlos si están en orden incorrecto.
3. Tras cada pasada, el elemento mayor se desplaza hacia el final.
4. Si en una pasada completa no ocurre ningún intercambio, el arreglo ya está ordenado.

#include <stdio.h>

int main() {
    int lista[] = {16, 5, 7, 32, 59, 10, 64, 1, 38, 41};
    int cantidad = 10;

    for (int pasada = 0; pasada < cantidad; pasada++) {
        _Bool huboIntercambio = 0;
        for (int pos = 0; pos < cantidad - 1 - pasada; pos++) {
            if (lista[pos] > lista[pos + 1]) {
                int auxiliar = lista[pos];
                lista[pos] = lista[pos + 1];
                lista[pos + 1] = auxiliar;
                huboIntercambio = 1;
            }
        }
        if (!huboIntercambio) {
            break;
        }
    }

    for (int n = 0; n < cantidad; n++) {
        printf("%d ", lista[n]);
    }
}

Práctica: Sucesión de Fibonacci con programación dinámica

La programación dinámica es una técnica que descompone un problema en subproblemas más pequeños, resolviendo cada uno solo una vez y almacenando sus resultados para evitar recálculos.

La sucesión de Fibonacci se define por la relación de recurrencia:

fibo[i] = fibo[i-1] + fibo[i-2]

Donde fibo[0] = 1 y fibo[1] = 1. Para calcular el valor en la posición n, basta con construir la sucesión desde el inicio hasta llegar a esa posición:

#include <stdio.h>

int main() {
    int posicion = 6;
    int fibo[posicion];

    fibo[0] = 1;
    fibo[1] = 1;

    for (int n = 2; n < posicion; n++) {
        fibo[n] = fibo[n - 1] + fibo[n - 2];
    }

    printf("%d", fibo[posicion - 1]);
}

8