Método 1:bucles anidados
Este es el enfoque más directo. Primero iteramos a través de columnas, luego filas dentro de cada columna.
`` `Java
columna de clase públicaMajortRaversal {
public static void traversecolumnmajor (int [] [] matrix) {
int filas =matrix.length;
int cols =matriz [0] .length; // asume matriz rectangular
para (int j =0; j
}
System.out.println (); // Newline después de cada columna
}
}
public static void main (string [] args) {
int [] [] matrix ={
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
System.out.println ("columna-major traversal:");
TraversecolumnMajor (matriz);
}
}
`` `` ``
Esto saldrá:
`` `` ``
Columna-Major Traversal:
1 4 7
2 5 8
3 6 9
`` `` ``
Método 2:bucle único con cálculo (más eficiente para matrices grandes)
Este método evita bucles anidados, que potencialmente ofrece un mejor rendimiento para matrices muy grandes al reducir la sobrecarga de bucle. Calcula el índice directamente.
`` `Java
columna de clase públicaMajortRaversAffient {
public static void traversecolumnMajorefficiente (int [] [] matriz) {
int filas =matrix.length;
int cols =matriz [0] .length;
para (int k =0; k
int j =k / filas; // índice de columna
System.out.print (matriz [i] [j] + "");
if ((k + 1) % filas ==0) {
System.out.println (); // Newline después de cada columna
}
}
}
public static void main (string [] args) {
int [] [] matrix ={
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
System.out.println ("columna-major traversal (eficiente):");
TraversecolumnMajoreftumber (matriz);
}
}
`` `` ``
Esto produce la misma salida que el método 1. La ganancia de eficiencia es más notable con matrices significativamente más grandes.
Consideraciones importantes:
* Matrices rectangulares: Ambos métodos asumen una matriz rectangular (todas las filas tienen el mismo número de columnas). Deberá agregar el manejo de errores (por ejemplo, verificar `matriz [i] .Length 'para cada fila) si se trata de matrices de formas irregulares.
* matrices irregulares: Si tiene una matriz irregular (donde las filas tienen diferentes números de columnas), el enfoque de bucle único (método 2) no funcionará directamente. Tendría que adaptarlo para manejar los recuentos de columnas variables por fila. El método 1 sería más fácilmente adaptable a este caso.
* Diseño de memoria: Mientras puede * atravesar * una matriz en el orden de columna mayor, las matrices de Java se almacenan en la memoria utilizando el orden de la fila. Esto significa que el recorrido de columna-mayor no será tan eficiente en caché como el recorrido de la fila.
Elija el método que mejor se adapte a sus necesidades y al tamaño de sus matrices. Para la mayoría de los casos, el Método 1 es más fácil de entender y mantener, mientras que el Método 2 podría proporcionar una ventaja de rendimiento para matrices extremadamente grandes. Recuerde manejar posibles excepciones, especialmente con matrices irregulares.