91. Recorriendo un arreglo bidimensional - Algoritmo

 

Recorrido de Arreglos Bidimensionales con Ciclos For

📋 Introducción

En este tutorial aprenderemos a recorrer arreglos bidimensionales utilizando ciclos for anidados. Esta técnica es fundamental para acceder a todos los elementos de una matriz de manera sistemática.

🎯 Concepto Básico

Un arreglo bidimensional podemos visualizarlo como una tabla con filas y columnas. Para recorrerlo completamente necesitamos:

1. Recorrer cada fila (primer ciclo for)

2. Para cada fila, recorrer todas sus columnas (segundo ciclo for anidado)

🔍 Ejemplo Visual

Consideremos este arreglo 2x3:

text

Fila 0: [50, 65, 41]
Fila 1: [365, 54, 3]

Los índices serían:

• (0,0) = 50

• (0,1) = 65

• (0,2) = 41

• (1,0) = 365

• (1,1) = 54

• (1,2) = 3

💻 Implementación en Código

Estructura General:

java

// Para un arreglo de 2 filas × 3 columnas
for (int i = 0; i < 2; i++) {           // Recorre filas
    for (int j = 0; j < 3; j++) {       // Recorre columnas
        System.out.println(arreglo[i][j]);
    }
}

Ejemplo Completo:

java

public class RecorridoArregloBidimensional {
    public static void main(String[] args) {
        // Declaración e inicialización del arreglo
        int[][] arreglo = {
            {50, 65, 41},
            {365, 54, 3}
        };
        
        // Recorrido del arreglo
        System.out.println("Recorriendo el arreglo bidimensional:");
        
        for (int fila = 0; fila < 2; fila++) {
            System.out.println("Fila " + fila + ":");
            
            for (int columna = 0; columna < 3; columna++) {
                System.out.println("  Posición [" + fila + "][" + columna + "] = " + arreglo[fila][columna]);
            }
        }
    }
}

🔄 Explicación Paso a Paso del Recorrido

Iteración 1:

• fila = 0 (0 < 2 → verdadero)

  • columna = 0 (0 < 3 → verdadero) → arreglo[0][0] = 50

  • columna = 1 (1 < 3 → verdadero) → arreglo[0][1] = 65

  • columna = 2 (2 < 3 → verdadero) → arreglo[0][2] = 41

  • columna = 3 (3 < 3 → falso) → sale del ciclo interno

Iteración 2:

• fila = 1 (1 < 2 → verdadero)

  • columna = 0 (0 < 3 → verdadero) → arreglo[1][0] = 365

  • columna = 1 (1 < 3 → verdadero) → arreglo[1][1] = 54

  • columna = 2 (2 < 3 → verdadero) → arreglo[1][2] = 3

  • columna = 3 (3 < 3 → falso) → sale del ciclo interno

Iteración 3:

• fila = 2 (2 < 2 → falso) → termina el ciclo

🚀 Versión Mejorada (Más Flexible)

java

public class RecorridoMejorado {
    public static void main(String[] args) {
        int[][] arreglo = {
            {50, 65, 41},
            {365, 54, 3}
        };
        
        // Usando arreglo.length para las filas
        // y arreglo[i].length para las columnas de cada fila
        for (int i = 0; i < arreglo.length; i++) {
            System.out.println("Fila " + i + ":");
            
            for (int j = 0; j < arreglo[i].length; j++) {
                System.out.println("  Columna " + j + ": " + arreglo[i][j]);
            }
        }
    }
}

📊 Salida Esperada

text

Recorriendo el arreglo bidimensional:
Fila 0:
  Posición [0][0] = 50
  Posición [0][1] = 65
  Posición [0][2] = 41
Fila 1:
  Posición [1][0] = 365
  Posición [1][1] = 54
  Posición [1][2] = 3

💡 Puntos Clave

1. Ciclo externo: Controla el índice de las filas

2. Ciclo interno: Controla el índice de las columnas para cada fila

3. Orden: Siempre se recorre fila por fila, columna por columna

4. Flexibilidad: Usar arreglo.length y arreglo[i].length hace el código adaptable a cualquier tamaño

🎓 Conclusión

El recorrido de arreglos bidimensionales con ciclos for anidados es una técnica esencial en programación. Dominar este concepto te permitirá trabajar eficientemente con matrices, tablas y cualquier estructura de datos bidimensional.