Difference between Multi-Dimensional array and a Jagged Array in C#

In this article, we will discuss the differences between Multidimensional and agged arrays. Jagged Arrays and Multi-Dimensional arrays are a facet of C# that every programmer who knows C# should be familiar with because arrays are one of the primary data structures that a language can have. These allow us to store and manipulate data in a well-structured and expeditious way, and choosing the proper array is one of the most important points in writing your code faster and more efficiently.

What are Multi-dimensional arrays?

The multidimensional array, popularly called a 'rectangular array' in C #, can be painted in 2D or 3D. Matrixes consist of rows and columns of data, including numerical and character-based data.

In order to have a multidimensional array, commas should be used within the square brackets.

Syntax:

It has the following syntax:

int[,] array=new int[4,4];//2d array declaration
int[,,] array=new int[4,4,4];//3d array declaration

Example:

Let us take an example to illustrate a 2D mutidimensional array in C#.

using System;  
public class MultiArrayExample  
{  
    public static void Main(string[] args)  
    {  
        int[,] array=new int[2,2];// A 2d array declaration
        array[0,1]=140;// the array values
  
        //iterating over the array  
        for(int i=0;i<2;i++){  
            for(int j=0;j<2;j++){  
                Console.Write(array[i,j]+" ");  
            }  
            Console.WriteLine();// for entering to a new linw
        }  
    }  
}

Output:

0 140 
0 0

Explanation:

This C# program demonstrates the usage of a 2x2 two-dimensional array, which is collected of integer types. It initializes an array and puts the value of 140 into the element at position [0, 1]. It follows next with nested for loops to go through the array and print out its elements. The value of an element is displayed using the Console.Write() method. The last statement of Console.WriteLine() will be given a call to move to a new line after printing each of the rows. The output of the program is "0 140" on the first line and "0 0" on the second line, which indicates the values for the array elements.

Key Features of Multi-Dimensional Arrays:

There are several key features of Multi-Dimensional Arrays in C#. Some main key features are as follows:

Rectangular Structure: Multi-dimensional arrays are quite similar to the expressions of numbers. They always have a rectangular structure in which the same number of columns exists for each row.
Fixed Size: When these arrays are created, the size of a low-dimensional array cannot be changed. We need to declare a start size for each dimension right at its declaration.
Continuous Memory Allocation: The sequential allocation of memory zones in multi-dimensional arrays speeds up their access.
Efficient for Matrix Operations: Multidimensional arrays are especially effective for dealing with and manipulating matrices and tables in which rows and columns have a uniform structure.

What is Jagged array?

A jagged array is an array where the member arrays can be of different sizes. Therefore, the size of each array compartment can be different. The elements of Jagged Array are the references that by default, are set to null. Jagged-Array also can be combined with a multidimensional array. The number of rows will be fixed at the time of declaration, but the number of columns can be changed. Declaration in a jagged array user needs to specify rows only. If the user is also going to include all the columns, it would be more like a Rectangular Array.

Syntax:

It has the following syntax:

Example:

Let us take an example to illustrate the Jagged Array in C#.

using System; 
class JaggedArray{
    // Main Method 
    public static void Main()
    {
        // the initial jagged array declaration 
        int[][] jagged_array = new int[3][];
        // the initial array elements 
        jagged_array[0] = new int[] {10, 20, 30, 40 };
        jagged_array[1] = new int[] {21, 94, 87}; 
        jagged_array[2] = new int[] {67, 29}; 
        // the print statement to display the array elements 
        for (int num = 0; num < jagged_array.Length; num++) 
        {
            // each row 
            System.Console.Write("Row({0}): ", num); 
            for (int k = 0; k < jagged_array[num].Length; k++) { 
                //The row elements 
                System.Console.Write("{0} ", jagged_array[num][k]); 
                } 
        System.Console.WriteLine(); 
     }
  }
    }

Output:

Row(0): 10 20 30 40 
Row(1): 21 94 87 
Row(2): 67 29

Explanation:

This program represents the realization of the jagged array in C#. The jagged arrayed array is an array of arrays; each element of the main array is an array of different lengths. In this program, a 2-dimensional jagged array is declared with 3 rows, and each row is given a collection of integers of a type different from the others. After that, the code takes the jagged array using nested loops and prints its elements and rows one by one. Therefore, the program displays the array elements, each row being followed by all its elements.

Key Features of Jagged Arrays:

There are several key features of Jagged Arrays in C#. Some main key features are as follows:

Irregular Structure: Jagged arrays have odd looking shapes because each row is of a different number of factors.
Dynamic Size: Unlike multidimensional arrays, which have a fixed number of rows, jagged arrays allow for dynamic resizing of rows. Every row may have a different length, and the number of rows can be increased or decreased depending on preferences.
Memory Allocation: Jagged arrays do not possess contiguous memory locations because they are non-consecutive. For each row, a separate array is an object, which is allocated iteratively to keep every row distinct.

Key Differences between Multi-dimensional array and Jagged array:

Difference between Multi-Dimensional array and a Jagged Array in C#

Here is the difference between a multi-dimensional array and a jagged array in C#:

Aspect	Multi-dimensional array	Jagged array
Definition	A *multidimensional array* is a rectangular bundle of elements where every element is located at one index, which also has multiple dimensions.	A Jagged array can also be defined as an array of arrays having each element contain an array of different sizes.
Memory allocation	It assigns a unique continuous memory block.	Each sub-array can contain a varying number of elements.
Memory Efficiency	It is more space efficient than linear data structures.	It allocates memory for all rows separately so that each row can have a varying number of elements.
Performance	Generally, it is more effective for accessing elements because it stores directly in memory without fragmentation.	It may be memory efficient when the length of rows varies greatly. Otherwise, elements may be slower to access due to non-contiguous memory access.
Flexibility	Less flexible because all rows have the same length.	More flexible as every row can have its own different length.
Storage Requirements	The amount of memory used depends on the maximum number of elements needed in different dimensions.	The additional memory is stored only on the actual elements.
Initializing with Different Dimensions	It cannot be achieved without the creation of another array.	The case is similar as each subsequent array may have had a different length.

Conclusion:

Multidimensional arrays have a rectangular structure, with every element located at a single position and all rows of the same length. They allocate a single continuous memory block for storing all elements, which makes accessing elements more efficient. From a jagged array's point of view, they have an inconsistent structure. Each row could be made of a different number of elements, which may help with dynamic resizing and flexibility. The memory for each row is allocated separately, which can lead to non-contiguous memory locations. Knowing what type of array we should use for our program, it is important to familiarize ourselves with the needs of the program. Use multi-dimensional arrays for a standard structure of fixed rectangular with all rows of the same length and fast accessibility. Use jagged arrays if we want flexibility and row length being changed, and they're suitable for situations where rows are different lengths.

Next TopicHashtable.ContainsKey(Object) Method in C#

← prev next →