Jagged arrays in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Jagged arrays

Declare jagged array variable

↓

Allocate outer array (rows)

↓

For each row: allocate inner array (columns)

↓

Access elements using two indices: arr[row

↓

Use nested loops to traverse or modify elements

Jagged arrays are arrays of arrays where each inner array can have different lengths. You first create the outer array, then create each inner array separately.

Execution Sample

C Sharp (C#)

int[][] jagged = new int[2][];
jagged[0] = new int[3] {1, 2, 3};
jagged[1] = new int[2] {4, 5};
int val = jagged[0][1];

This code creates a jagged array with 2 rows, assigns arrays of different lengths to each row, and accesses an element.

Execution Table

Step	Action	Outer Array State	Inner Array Allocated	Access/Value
1	Declare jagged array variable	null	none	none
2	Allocate outer array with 2 rows	[null, null]	none	none
3	Allocate inner array at jagged[0] with length 3	[array, null]	jagged[0] = [0,0,0]	none
4	Assign values to jagged[0]	[[1,2,3], null]	jagged[0] = [1,2,3]	none
5	Allocate inner array at jagged[1] with length 2	[[1,2,3], array]	jagged[1] = [0,0]	none
6	Assign values to jagged[1]	[[1,2,3], [4,5]]	jagged[1] = [4,5]	none
7	Access jagged[0][1]	[[1,2,3], [4,5]]	none	2
8	Access jagged[1][0]	[[1,2,3], [4,5]]	none	4
9	End of execution	[[1,2,3], [4,5]]	none	none

💡 All arrays allocated and accessed; execution ends.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	Final
jagged	null	[null, null]	[array, null]	[[1,2,3], null]	[[1,2,3], array]	[[1,2,3], [4,5]]	[[1,2,3], [4,5]]	[[1,2,3], [4,5]]
jagged[0]	N/A	N/A	[0,0,0]	[1,2,3]	[1,2,3]	[1,2,3]	[1,2,3]	[1,2,3]
jagged[1]	N/A	N/A	N/A	N/A	[0,0]	[4,5]	[4,5]	[4,5]
val	N/A	N/A	N/A	N/A	N/A	N/A	2	2

Key Moments - 3 Insights

Why do we need to allocate each inner array separately?

Because jagged arrays are arrays of arrays, each inner array can have different sizes and must be created individually as shown in steps 3 and 5.

What happens if we try to access an inner array before allocating it?

It will cause a runtime error because the inner array is null until allocated, as seen in step 2 where inner arrays are null.

How do we access elements in a jagged array?

We use two indices: first for the outer array (row), then for the inner array (column), like jagged[0][1] in step 7.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of jagged[1][1] after step 6?

A 5

B 4

C 0

D null

💡 Hint

Check the 'Inner Array Allocated' column at step 6 where jagged[1] is assigned [4,5].

At which step is the outer array allocated?

A Step 1

B Step 2

C Step 3

D Step 5

💡 Hint

Look at the 'Action' column for allocation of the outer array.

If jagged[0] was not allocated, what would happen when accessing jagged[0][1]?

A It would return null

B It would return 0

C It would cause a runtime error

D It would allocate the inner array automatically

💡 Hint

Refer to the key moment about accessing inner arrays before allocation.

Concept Snapshot

Jagged arrays are arrays of arrays with different lengths.
Declare outer array first: int[][] arr = new int[rows][];
Allocate each inner array separately: arr[0] = new int[length];
Access elements with two indices: arr[row][col].
Useful for non-rectangular data structures.

Full Transcript

Jagged arrays in C# are arrays where each element is itself an array, allowing different lengths for each inner array. First, you declare the outer array with a fixed number of rows. Then, you allocate each inner array separately, which can have different sizes. You access elements using two indices: the first for the outer array (row), and the second for the inner array (column). This allows flexible data structures that are not rectangular. The execution trace shows declaring the jagged array, allocating the outer array, allocating and assigning inner arrays, and accessing elements safely after allocation.