Requisito previo: Arrays en C#
Una array irregular es una array de arrays de modo que las arrays de miembros pueden tener diferentes tamaños. En otras palabras, la longitud de cada índice de array puede diferir. Los elementos de Jagged Array son tipos de referencia y se inicializan en nulo de forma predeterminada. Jagged Array también se puede mezclar con arrays multidimensionales. Aquí, el número de filas se fijará en el momento de la declaración, pero puede variar el número de columnas.
Declaración
En arrays irregulares, el usuario debe proporcionar solo el número de filas. Si el usuario también va a proporcionar el número de columnas, esta array ya no será Jagged Array.
Sintaxis:
data_type[][] name_of_array = new data_type[rows][]
Ejemplo:
int[][] jagged_arr = new int[4][]
En el ejemplo anterior, se declara una array unidimensional que tiene 4 elementos (filas), cada uno de los cuales es una array 1-D de enteros.
Inicialización
Los elementos de Jagged Array deben inicializarse antes de su uso. Puede inicializar por separado cada elemento de la array. Hay muchas formas de inicializar el elemento de la array Jagged.
Ejemplo 1: proporcionar el tamaño de cada elemento de la array por separado. Aquí cada uno de los elementos es una array 1-D de enteros donde:
- La primera fila o elemento es una array de 2 enteros.
- La segunda fila o elemento es una array de 4 enteros.
- La tercera fila o elemento es una array de 6 enteros.
- La cuarta fila o elemento es una array de 7 enteros.
jagged_arr[0] = new int[2]; jagged_arr[1] = new int[4]; jagged_arr[2] = new int[6]; jagged_arr[3] = new int[7];
Ejemplo 2: cuando no se necesita el tamaño de la array, sus elementos se pueden inicializar con valores directos de la siguiente manera:
jagged_arr[0] = new int[] {1, 2, 3, 4};
jagged_arr[1] = new int[] {11, 34, 67};
jagged_arr[2] = new int[] {89, 23};
jagged_arr[3] = new int[] {0, 45, 78, 53, 99};
Declaración e inicialización
Ejemplo 1: uso del método directo
int[][] jagged_arr = new int[][]
{
new int[] {1, 2, 3, 4},
new int[] {11, 34, 67},
new int[] {89, 23},
new int[] {0, 45, 78, 53, 99}
};
Ejemplo 2: uso del método abreviado. No existe una inicialización predeterminada para los elementos, por lo que un usuario no puede omitir el nuevo operador de la inicialización de los elementos.
int[][] jagged_arr =
{
new int[] {1, 2, 3, 4},
new int[] {11, 34, 67},
new int[] {89, 23},
new int[] {0, 45, 78, 53, 99}
};
Accediendo a los Elementos
Para acceder a los elementos de la array irregular, el usuario debe especificar la fila y la columna con el nombre de la array.
Ejemplo:
// Accessing & Assigning 99 to the third element ([2]) of the second array ([1]) jagged_arr[1][2] = 99; // Accessing & Assigning 47 to the first element ([0]) of the fourth array ([3]): jagged_arr[3][0] = 47;
Programa:
// C# program to illustrate the declaration
// and Initialization of Jagged Arrays
using System;
class GFG {
// Main Method
public static void Main()
{
// Declare the Jagged Array of four elements:
int[][] jagged_arr = new int[4][];
// Initialize the elements
jagged_arr[0] = new int[] {1, 2, 3, 4};
jagged_arr[1] = new int[] {11, 34, 67};
jagged_arr[2] = new int[] {89, 23};
jagged_arr[3] = new int[] {0, 45, 78, 53, 99};
// Display the array elements:
for (int n = 0; n < jagged_arr.Length; n++) {
// Print the row number
System.Console.Write("Row({0}): ", n);
for (int k = 0; k < jagged_arr[n].Length; k++) {
// Print the elements in the row
System.Console.Write("{0} ", jagged_arr[n][k]);
}
System.Console.WriteLine();
}
}
}
Producción:
Row(0): 1 2 3 4 Row(1): 11 34 67 Row(2): 89 23 Row(3): 0 45 78 53 99
Arrays irregulares con arrays multidimensionales
Es posible mezclar arrays irregulares y multidimensionales. A continuación se muestra la declaración e inicialización de una array irregular 1-D que contiene cuatro elementos de array bidimensionales de diferentes tamaños.
Ejemplo:
int[][, ] jagged_arr1 = new int[4][, ]
{
new int[, ] { {1, 3}, {5, 7} },
new int[, ] { {0, 2}, {4, 6}, {8, 10} },
new int[, ] { {7, 8}, {3, 1}, {0, 6} },
new int[, ] { {11, 22}, {99, 88}, {0, 9} }
};
Un usuario puede acceder a los elementos individuales como se muestra en el siguiente ejemplo, que muestra el valor del elemento [2, 0] de la segunda array (es decir, el valor es 8)
Ejemplo:
System.Console.Write("{0}", jagged_arr1[1][1, 0]);
Programa:
// C# program to illustrate the Mixing of 1-D
// Jagged Array with the four 2-D array
using System;
namespace geeksforgeeks {
class GFG {
// Main Method
public static void Main()
{
// Declaration and Initialization of
// Jagged array with 4 2-D arrays
int[][, ] jagged_arr1 = new int[4][, ] {new int[, ] {{1, 3}, {5, 7}},
new int[, ] {{0, 2}, {4, 6}, {8, 10}},
new int[, ] {{7, 8}, {3, 1}, {0, 6}},
new int[, ] {{11, 22}, {99, 88}, {0, 9}}};
// Display the array elements:
// Length method returns the number of
// arrays contained in the jagged array
for (int i = 0; i < jagged_arr1.Length; i++)
{
int x = 0;
// GetLength method takes integer x which
// specifies the dimension of the array
for (int j = 0; j < jagged_arr1[i].GetLength(x); j++)
{
// Rank is used to determine the total
// dimensions of an array
for (int k = 0; k < jagged_arr1[j].Rank; k++)
Console.Write("Jagged_Array[" + i + "][" + j + ", " + k + "]: "
+ jagged_arr1[i][j, k] + " ");
Console.WriteLine();
}
x++;
Console.WriteLine();
}
}
}
}
Producción:
Jagged_Array[0][0, 0]: 1 Jagged_Array[0][0, 1]: 3 Jagged_Array[0][1, 0]: 5 Jagged_Array[0][1, 1]: 7 Jagged_Array[1][0, 0]: 0 Jagged_Array[1][0, 1]: 2 Jagged_Array[1][1, 0]: 4 Jagged_Array[1][1, 1]: 6 Jagged_Array[1][2, 0]: 8 Jagged_Array[1][2, 1]: 10 Jagged_Array[2][0, 0]: 7 Jagged_Array[2][0, 1]: 8 Jagged_Array[2][1, 0]: 3 Jagged_Array[2][1, 1]: 1 Jagged_Array[2][2, 0]: 0 Jagged_Array[2][2, 1]: 6 Jagged_Array[3][0, 0]: 11 Jagged_Array[3][0, 1]: 22 Jagged_Array[3][1, 0]: 99 Jagged_Array[3][1, 1]: 88 Jagged_Array[3][2, 0]: 0 Jagged_Array[3][2, 1]: 9