Dominando arrays escalonados en C#: Declaración, inicialización y acceso

Array escalonado (jagged array) en C#

En este tutorial, aprenderemos sobre el array escalonado en C#. Aprenderemos a declarar, inicializar y acceder al array escalonado con la ayuda de ejemplos.

En C#, un array escalonado consiste en múltiples arrays como sus elementos. Sin embargo, a diferencia de los arrays multidimensionales, cada array dentro de un array escalonado puede ser de diferentes tamaños.

Antes de aprender sobre array escalonado, asegúrate de conocer:

• Arrays en C#
• Arrays multidimensionales en C#

---

Declaración de array escalonado en C#

Aquí está la sintaxis para declarar un array escalonado en C#:

dataType[ ][ ] nameOfArray = new dataType[rows][ ];

Veamos un ejemplo:

// declara array escalonado
int[ ][ ] jaggedArray = new int[2][ ];

Aquí,

• int - tipo de dato del array
• [][] - representa array escalonado
• jaggedArray - nombre del array escalonado
• [2][] - representa el número de elementos (arrays) dentro del array escalonado

Como sabemos que cada elemento de un array escalonado es también un array, podemos establecer el tamaño del array individual. Por ejemplo:

// establece tamaño del primer array como 3
jaggedArray[0] = new int[3];
// establece tamaño del segundo array como 2
jaggedArray[1] = new int[2];

---

Inicializando array escalonado

Hay diferentes formas de inicializar un array escalonado. Por ejemplo:

1. Usando el número de índice

Una vez declaramos un array escalonado, podemos usar el número de índice para inicializarlo. Por ejemplo:

// inicializa el primer array
jaggedArray[0][0] = 1;
jaggedArray[0][1] = 3;
jaggedArray[0][2] = 5;
// inicializa el segundo array
jaggedArray[1][0] = 2;
jaggedArray[1][1] = 4;

Aquí,

• índice en el primer corchete representa el índice del elemento del array escalonado
• índice en el segundo corchete representa el índice del elemento dentro de cada elemento del array escalonado

2. Inicializar sin establecer tamaño de elementos del array

// declarando array escalonado string
int[ ][ ] jaggedArray = new int[2] [ ];
// inicializa cada array
jaggedArray[0] = new int[] {1, 3, 5};
jaggedArray[1] = new int[] {2, 4};

3. Inicializar mientras se declara el Array Escalonado

int[ ][ ] jaggedArray = { new int[ ] {10, 20, 30}, new int[ ] {11, 22}, new int[ ] {88, 99} };

---

Accediendo a elementos de un array escalonado

Podemos acceder a los elementos del array escalonado usando el número de índice. Por ejemplo:

// accede al primer elemento del segundo array
jaggedArray[1][0];
// accede al segundo elemento del segundo array
jaggedArray[1][1];
// accede al segundo elemento del primer array
jaggedArray[0][1];

---

Ejemplo: Array escalonado en C#

using System;
namespace JaggedArray {
    class Program {
        static void Main(string[] args) {
            // crea un array escalonado
            int[ ][ ] jaggedArray = { new int[] {1, 3, 5}, new int[] {2, 4}, };
            // imprime elementos del array escalonado
            Console.WriteLine("jaggedArray[1][0]: " + jaggedArray[1][0]);
            Console.WriteLine("jaggedArray[1][1]: " + jaggedArray[1][1]);
            Console.WriteLine("jaggedArray[0][2]: " + jaggedArray[0][2]);
            Console.ReadLine();
        }
    }
}

Salida

jaggedArray[1][0]: 2
jaggedArray[1][1]: 4
jaggedArray[0][2]: 5

Aquí, dentro de un array escalonado:

• jaggedArray[1][0] - primer elemento del segundo array
• jaggedArray[1][1] - segundo elemento del segundo array
• jaggedArray[0][2] - tercer elemento del primer array

---

Iterando a través de un array escalonado

En C#, podemos usar bucles para iterar a través de cada elemento del array escalonado. Por ejemplo:

using System;
namespace JaggedArray {
    class Program {
        static void Main(string[] args) {
            // declara un array escalonado
            int[][] jaggedArray = new int[2][];
            // establece tamaño de elementos del Array Escalonado
            jaggedArray[0] = new int[3];
            jaggedArray[1] = new int[2];
            // inicializa el primer array
            jaggedArray[0][0] = 1;
            jaggedArray[0][1] = 3;
            jaggedArray[0][2] = 5;
            // inicializa el segundo array
            jaggedArray[1][0] = 2;
            jaggedArray[1][1] = 2;
            // bucle for externo
            for (int i = 0; i < jaggedArray.Length; i++) {
                Console.Write("Element "+ i +": ");
                // bucle for interno
                for (int j = 0; j < jaggedArray[i].Length; j++) {
                    Console.Write(jaggedArray[i][j] + " ");
                }
                Console.WriteLine();
            }
            Console.ReadLine();
        }
    }
}

Salida

Element 0: 1 3 5
Element 1: 2 2

En el ejemplo anterior, hemos usado un bucle for anidado para iterar a través del array escalonado. Aquí,

1. Bucle for externo

• para acceder a los elementos (arrays) del array escalonado
• jaggedArray.Length - da el tamaño del array escalonado

2. Bucle for interno

• para acceder a los elementos del array individual dentro del array escalonado.
• jaggedArray[i].Length - da el tamaño de elementos del i-ésimo array dentro del array escalonado

---

Array escalonado con array multidimensional

En C#, también podemos usar arrays multidimensionales como elementos de Array Escalonado. Por ejemplo:

int[ ][ , ] jaggedArrayTwoD = new int[2][ , ] { new int[,] { {1, 8}, {6, 7} }, new int[,] { {0, 3}, {5, 6}, {9, 10} } };

Aquí, cada elemento del array escalonado es un array multidimensional:

• new int[,] { {1, 8}, {6, 7} } - array 2D con 2 elementos
• new int[ , ] { {0, 3}, {5, 6}, {9, 10} } - array 2D con 3 elementos

Veamos un ejemplo:

using System;
namespace JaggedArray {
    class Program {
        static void Main(string[] args) {
            // declara e inicializa array escalonado con array 2D
            int[][,] jaggedArray = new int[3][ , ] {
                new int[ , ] { {1, 8}, {6, 7} },
                new int[ , ] { {0, 3}, {5, 6}, {9, 10} },
                new int[ , ] { {11, 23}, {100, 88}, {0, 10} }
            };
            Console.WriteLine(jaggedArray[0][0, 1]);
            Console.WriteLine(jaggedArray[1][2, 1]);
            Console.WriteLine(jaggedArray[2][1, 0]);
            Console.ReadLine();
        }
    }
}

Salida

8 10 100

En el ejemplo anterior, observa el código:

jaggedArray[0][0, 1]

Aquí,

• [0] - representa el primer elemento (array 2D) del array escalonado
• [0, 1] - representa el segundo elemento del primer array dentro del array 2D