Jagged Arrays in C#

A jagged array is an array of arrays, where each element is itself an array that can have a different length. Rows are fixed at declaration, but columns can vary. It can also combine with multidimensional arrays.

Example: Declaring a jagged array with 3 rows

int[][] jaggedArr = new int[3][];

// Initialize each row with different lengths
jaggedArr[0] = new int[] { 1, 2, 3 };
jaggedArr[1] = new int[] { 4, 5 };
jaggedArr[2] = new int[] { 6, 7, 8, 9 };

Here's a visual representation how Jagged Arrays in C# are stored in Heap Memory:

Declaration and Initialization

For declaring we specify the type of elements inside the inner arrays and the number of rows in the outer array. Unlike multi-dimensional arrays, where the size of all dimensions is fixed, a jagged array allows for variable lengths of inner arrays.

Syntax

data_type[ ][ ] name_of_array = new data_type[rows][ ]

Initialization of Jagged Arrays

Method 1: Initialized with indexes.

// Add in the first row
jagged_arr[0][0] = 1;
jagged_arr[0][1] = 2;

Method 2: We can directly insert the arrays in each row of the jagged array in this way.

// Each row having different size of array as a element
jagged_arr[0] = new int[] {1, 2, 3, 4};
jagged_arr[1] = new int[] {11, 34, 67};

Declaration with Initialization

There are two methods to perform these operations one is

Method 1: Using the Direct Method

int[][] jagged_arr = new int[][] {
new int[] {1, 2, 3, 4},
new int[] {11, 34, 67}
};

Method 2: Using Short-hand Method.

There is no default initialization for the elements so a user cannot omit the new operator from the element's initialization.

int[][] jagged_arr = {
new int[] {1, 2, 3, 4},
new int[] {11, 34, 67}
};

Example : Basic program to implement jagged array

using System;

class Geeks{
    static void Main(){
        // Declaration  
        int[][] jaggedArray = new int[3][];
      
      	// Initialization
        jaggedArray[0] = new int[] { 1, 2 };
        jaggedArray[1] = new int[] { 3, 4, 5 };
        jaggedArray[2] = new int[] { 6, 7, 8, 9 };

      	// Iterating the elements
        for (int i = 0; i < jaggedArray.Length; i++) 
        {
            Console.Write("Row " + i + ": ");
            foreach(int num in jaggedArray[i])
                Console.Write(num + " ");
          
            Console.WriteLine();
        }
    }
}

Row 0: 1 2 
Row 1: 3 4 5 
Row 2: 6 7 8 9 

Accessing and Modifying Elements

We can access elements in a jagged array using two indices. The first index is from the outer array and the second index corresponds to the element in the row of the inner array

Example: In this example, we learn how to access and modify elements of a jagged array

using System;

class Geeks{
    static void Main(string[] args){
        // Declaration of a jagged array with 3 rows
        int[][] arr = new int[3][];
        
        // Initializing each row of the jagged array First row
        arr[0] = new int[] { 1, 2, 3, 4}; 
      
      	// Second row
        arr[1] = new int[] { 4, 5, 6 }; 
      
      	// Third row (only two elements)
        arr[2] = new int[] { 7, 8 };    

        // Accessing the third element in second row
        int value = arr[1][2]; 
        
        // Modifying the second element in the first row (from 2 to 10)
        arr[0][1] = 10; 
        
        // Outputting the modified value
        Console.WriteLine(arr[0][1]);  

        // Outputting the accessed value for verification
        Console.WriteLine("Accessed value: " + value);
    }
}

10
Accessed value: 6

Iterating in Multidimensional Array

To iterate through a jagged array, we can use nested loops. The outer loop iterates through the rows and the inner loop iterates through the elements in each row.

Example:

using System;

public class Geeks
{
	public static void Main(string[] args)
	{
		// Declaration and Initialization with Multidimensional Array
		int[][,] arr = new int[2][,] {
			new int[, ] { { 1, 3 }, { 5, 7 } },
			new int[, ] { { 0, 2 }, { 4, 6 }, { 8, 10 } }
		};
		// Display the array elements:
		for (int i = 0; i < arr.Length; i++){
			for (int j = 0; j < arr[i].GetLength(0); j++){
				for (int k = 0; k < arr[i].GetLength(1); k++){
					Console.Write("arr[" + i + "][" + j + ", " + k + "] => " + arr[i][j, k] + " ");
				}
				Console.WriteLine();
			}
			Console.WriteLine();
		}
	}
}

arr[0][0, 0] => 1 arr[0][0, 1] => 3 
arr[0][1, 0] => 5 arr[0][1, 1] => 7 

arr[1][0, 0] => 0 arr[1][0, 1] => 2 
arr[1][1, 0] => 4 arr[1][1, 1] => 6 
arr[1][2, 0] => 8 arr[1][2, 1] => 10 

Advantages of Jagged Arrays

• Flexibility: It allows us to define the variable number of arrays inside each row of an array.
• Dynamic Size: Allow us to add different array sizes in the run-time.
• Enhance Readability: It makes code more readable and easy to understand at first look.
• Memory efficient: Allow each inner array with a different size, they can be more memory-efficient when storing irregular data.