6.a.1 - Arrays (Matrices)

1.1 ¿Por qué necesitamos los arrays?

Imagina que necesitas almacenar las notas de 30 estudiantes en tu programa. Sin arrays, tendrías que crear 30 variables diferentes: nota1, nota2, nota3, ..., nota30. Esto sería muy tedioso de escribir y difícil de manejar.

Además, ¿cómo harías para calcular la media de todas las notas? Tendrías que escribir una fórmula gigantesca sumando las 30 variables una por una.

Los arrays (también llamados matrices, arreglos o vectores) resuelven este problema permitiéndonos almacenar múltiples valores del mismo tipo en una sola variable, organizados en posiciones numeradas llamadas índices.

1.2 ¿Qué es un array? Índice vs Valor

Un array es una estructura de datos que permite almacenar una colección de elementos del mismo tipo en posiciones contiguas de memoria. Cada elemento se accede mediante un índice (posición).

Conceptos clave:

• Índice: Es la posición de un elemento dentro del array. En la mayoría de los lenguajes (incluyendo Java y PSeInt), los índices comienzan en 0 (cero).
• Valor: Es el dato almacenado en una posición específica del array.
• Tamaño: Es el número máximo de elementos que puede almacenar el array.
• Elemento: Cada uno de los valores almacenados.

Representación visual de un array:

Array: notas
Índice:    0      1      2      3      4
        +-------+-------+-------+-------+
Valor:  | 7.5   | 8.0   | 6.5   | 9.0   | 5.5   |
        +-------+-------+-------+-------+
        
notas[0] = 7.5  (en la posición 0 está el valor 7.5)
notas[1] = 8.0  (en la posición 1 está el valor 8.0)
notas[2] = 6.5  (en la posición 2 está el valor 6.5)
...
                

1.3 Tipos de arrays y su nomenclatura

Según su dimensión (número de índices necesarios para localizar un elemento), los arrays reciben diferentes nombres:

En este curso nos centraremos en los arrays de 1 dimensión (vectores) y 2 dimensiones (matrices), que son los más comunes en los primeros pasos de programación.

1.4 Declaración de arrays en PSeInt y Java

En PSeInt:

// Declarar un vector de 5 enteros
Definir notas Como Entero
Dimension notas[5]

// También se puede hacer en una sola línea
Definir edades[10] Como Entero

// Declarar una matriz de 3x4 (3 filas, 4 columnas)
Definir matriz Como Entero
Dimension matriz[3, 4]
                

En Java (con wrappers):

// Declaración e inicialización de un array de 5 enteros
Integer[] notas = new Integer[5];

// Declaración por separado
Integer[] edades;
edades = new Integer[10];

// Inicialización con valores conocidos
Integer[] numeros = {10, 20, 30, 40, 50};

// Declarar una matriz de 3x4 (3 filas, 4 columnas)
Integer[][] matriz = new Integer[3][4];

// Inicialización de matriz con valores
Integer[][] identidad = {
    {1, 0, 0},
    {0, 1, 0},
    {0, 0, 1}
};
                

1.5 Inserción y recuperación de valores

Ejemplo en PSeInt:

Algoritmo InsercionRecuperacion
    Definir notas Como Entero
    Dimension notas[5]
    
    // Insertar valores
    notas[0] <- 7
    notas[1] <- 8
    notas[2] <- 6
    notas[3] <- 9
    notas[4] <- 5
    
    // Recuperar y mostrar valores
    Escribir "La primera nota es: ", notas[0]
    Escribir "La tercera nota es: ", notas[2]
    Escribir "La última nota es: ", notas[4]
FinAlgoritmo
                

Ejemplo en Java:

public class InsercionRecuperacion {
    public static void main(String[] args) {
        // Declarar e insertar valores
        Integer[] notas = new Integer[5];
        notas[0] = 7;
        notas[1] = 8;
        notas[2] = 6;
        notas[3] = 9;
        notas[4] = 5;
        
        // Recuperar y mostrar valores
        System.out.println("La primera nota es: " + notas[0]);
        System.out.println("La tercera nota es: " + notas[2]);
        System.out.println("La última nota es: " + notas[4]);
    }
}
                

1.6 Recorrido de arrays (bucles)

La forma más eficiente de recorrer un array es usando un bucle for que itere sobre los índices.

Ejemplo en PSeInt:

Algoritmo RecorridoArray
    Definir i Como Entero
    Definir temperaturas[7] Como Entero
    
    // Rellenar con valores de ejemplo
    Para i <- 0 Hasta 6 Hacer
        temperaturas[i] <- 20 + i
    FinPara
    
    // Recorrer y mostrar cada valor
    Escribir "Temperaturas de la semana:"
    Para i <- 0 Hasta 6 Hacer
        Escribir "Día ", i + 1, ": ", temperaturas[i]
    FinPara
    
    // Calcular la suma total
    Definir suma Como Entero
    suma <- 0
    Para i <- 0 Hasta 6 Hacer
        suma <- suma + temperaturas[i]
    FinPara
    Escribir "Suma total: ", suma
FinAlgoritmo
                

Ejemplo en Java:

public class RecorridoArray {
    public static void main(String[] args) {
        Integer[] temperaturas = new Integer[7];
        
        // Rellenar con valores de ejemplo
        for (Integer i = 0; i < 7; i = i + 1) {
            temperaturas[i] = 20 + i;
        }
        
        // Recorrer y mostrar cada valor
        System.out.println("Temperaturas de la semana:");
        for (Integer i = 0; i < 7; i = i + 1) {
            System.out.println("Día " + (i + 1) + ": " + temperaturas[i]);
        }
        
        // Calcular la suma total
        Integer suma = 0;
        for (Integer i = 0; i < 7; i = i + 1) {
            suma = suma + temperaturas[i];
        }
        System.out.println("Suma total: " + suma);
    }
}
                

Recorrido de una matriz (2 dimensiones):

public class RecorridoMatriz {
    public static void main(String[] args) {
        Integer[][] matriz = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        System.out.println("Matriz 3x3:");
        for (Integer i = 0; i < 3; i = i + 1) {
            for (Integer j = 0; j < 3; j = j + 1) {
                System.out.print(matriz[i][j] + " ");
            }
            System.out.println();  // Salto de línea al final de cada fila
        }
    }
}
// Salida:
// 1 2 3
// 4 5 6
// 7 8 9
                

1.7 Búsqueda en arrays

Una operación muy común es buscar un valor dentro de un array para saber si existe y en qué posición se encuentra.

Búsqueda secuencial (lineal):

public class BusquedaSecuencial {
    public static void main(String[] args) {
        Integer[] numeros = {15, 23, 42, 8, 17, 31, 5};
        Integer valorBuscado = 17;
        Boolean encontrado = false;
        Integer posicion = -1;
        
        for (Integer i = 0; i < numeros.length; i = i + 1) {
            if (numeros[i].equals(valorBuscado)) {
                encontrado = true;
                posicion = i;
                break;  // Salimos del bucle al encontrarlo
            }
        }
        
        if (encontrado) {
            System.out.println("El valor " + valorBuscado + " se encontró en la posición " + posicion);
        } else {
            System.out.println("El valor " + valorBuscado + " no se encontró");
        }
    }
}
                

1.8 Copia de arrays

Copiar arrays requiere atención, porque asignar un array a otro no lo copia, solo hace que ambas variables apunten al mismo array.

Asignación incorrecta (referencia compartida):

Integer[] original = {1, 2, 3, 4, 5};
Integer[] copia = original;  // ¡NO es una copia independiente!

copia[0] = 99;
System.out.println(original[0]);  // También muestra 99 (el original se modificó)
                

Copia correcta (elemento por elemento):

public class CopiaArray {
    public static void main(String[] args) {
        Integer[] original = {1, 2, 3, 4, 5};
        Integer[] copia = new Integer[original.length];
        
        // Copiar elemento por elemento
        for (Integer i = 0; i < original.length; i = i + 1) {
            copia[i] = original[i];
        }
        
        // Modificamos la copia
        copia[0] = 99;
        
        System.out.println("Original[0]: " + original[0]);  // 1
        System.out.println("Copia[0]: " + copia[0]);        // 99
    }
}
                

En PSeInt (asignación directa funciona como copia):

Algoritmo CopiaArrayPSeInt
    Definir original[5] Como Entero
    Definir copia[5] Como Entero
    Definir i Como Entero
    
    original[0] <- 1
    original[1] <- 2
    original[2] <- 3
    original[3] <- 4
    original[4] <- 5
    
    // En PSeInt, asignar un array a otro SÍ crea una copia
    copia <- original
    
    // Modificamos la copia
    copia[0] <- 99
    
    Escribir "Original[0]: ", original[0]  // 1
    Escribir "Copia[0]: ", copia[0]        // 99
FinAlgoritmo