Arrays

1D Arrays

What is an array?

• An array is an ordered, static set of elements
• Can only store 1 data type
• A 1D array is a linear array

Structure of a 1D array

Example in pseudocode

• In this example we will be creating a one-dimensional array called ‘array’ which contains 5 integers.
• To create the array we can use the following syntax:
  • array[0] = 1
  • array[1] = 2
  • array[2] = 3
  • array[3] = 4
  • array[4] = 5
• We can access the individual elements of the array by using the following syntax:
  • array[index]
• We can also modify the individual elements by assigning new values to specific indices using the following syntax:
  • array[index] = newValue
• We can also use the len function to determine the length of the array by using the following syntax:
  • len(array)
• In the example we have iterated through the array to output each element within the array. We have used a For Loop for this.

// Creating a one-dimensional array
array array[5]
array[0] = 1
array[1] = 2
array[2] = 3
array[3] = 4
array[4] = 5

// Accessing elements of the array
print(array[0])
print(array[2])

// Modifying elements of the array
array[1] = 10
print(array)

// Iterating over the array
for element in array
  print(element)

// Length of array
length = len(array)
print(length)

Example in Python

• Creating a one-dimensional array called ‘array’ which contains 5 integers.
• Create the array with the following syntax:
  • array = [1, 2, 3, 4, 5]
• Access the individual elements of the array by using the following syntax:
  • array[index]
• Modify the individual elements by assigning new values to specific indices using the following syntax:
  • array[index] = newValue
• Use the len function to determine the length of the array by using the following syntax:
  • len(array)
• In the example the array has been iterated through to output each element within the array. A for loop has been used for this

# Creating a one-dimensional array
array = [1, 2, 3, 4, 5]
 
# Accessing elements of the array
print(array[0])   # Output: 1
print(array[2])   # Output: 3
 
# Modifying elements of the array
array[1] = 10
print(array)     # Output: [1, 10, 3, 4, 5]
 
# Iterating over the array
for element in array:
     print(element)
 
# Output:
# 1
# 10
# 3
# 4
# 5
 
# Length of the array
length = len(array)
print(length)    # Output: 5

Example in Java

• Creating a one-dimensional array called ‘array’ which contains 5 integers.
• To create the array, use the following syntax:
  • int[] array = {1, 2, 3, 4, 5};
• Access the individual elements of the array by using the following syntax:
  • array[index]
• Modify the individual elements by assigning new values to specific indices using the following syntax:
  • array[index] = newValue;
• Use the following syntax to print the array as a string:
  • arrays.toString(array)
• Use the length function to determine the length of the array by using the following syntax:
  • array.length;
• In the example, the array has been iterated through to output each element within the array. A for loop has been used for this

public class OneDimensionalArrayExample {
     public static void main(String[] args) {
         // Creating a one-dimensional array
         int[] array = {1, 2, 3, 4, 5};
 
         // Accessing elements of the array
         System.out.println(array[0]);   // Output: 1
         System.out.println(array[2]);   // Output: 3
 
         // Modifying elements of the array
         array[1] = 10;
         System.out.println(Arrays.toString(array));   // Output: [1, 10, 3, 4, 5]
 
         // Iterating over the array
         for (int i = 0; i < array.length; i++) {
             System.out.println(array[i]);
         }
 
         // Output:
         // 1
         // 10
         // 3
         // 4
         // 5
 
         // Length of the array
         int length = array.length;
         System.out.println(length);   // Output: 5
     }
}

2D Arrays

• A 2D array can be visualised as a table
• When navigating through a 2D array you first have to go down the rows and then across the columns to find a position within the array

Structure of a 2D array

Example in Pseudocode

// Define the dimensions of the 2D array
ROWS = 3
COLS = 4

// Create a 2D array with the specified dimensions
array_2d = new Array[ROWS][COLS]

// Initialize the 2D array with values (optional)
for row = 0 to ROWS-1:
     for col = 0 to COLS-1:
         array_2d[row][col] = initial_value

// Accessing elements in the 2D array
value = array_2d[row_index][col_index]

Example in Python

# Method 1: Initialising an empty 2D array
rows = 3
cols = 4
array_2d = [[0 for _ in range(cols)] for _ in range(rows)]
# The above code creates a 2D array with 3 rows and 4 columns, filled with zeros.
 
# Method 2: Initialising a 2D array with values
array_2d = [[1, 2, 3],
            [4, 5, 6],
            [7, 8, 9]]
# The above code creates a 2D array with 3 rows and 3 columns, with the specified values.
 
# Accessing elements in the 2D array
print(array_2d[0][0])  # Output: 1
print(array_2d[1][2])  # Output: 6

Example in Java

// Method 1: Initialising an empty 2D array
int rows = 3;
int cols = 4;
int[][] array2D = new int[rows][cols];
// The above code creates a 2D array with 3 rows and 4 columns, filled with zeros.
 
// Method 2: Initialising a 2D array with values
int[][] array2D = { {1, 2, 3},
                    {4, 5, 6},
                    {7, 8, 9} };
// The above code creates a 2D array with 3 rows and 3 columns, with the specified values.
 
// Accessing elements in the 2D array
System.out.println(array2D[0][0]); // Output: 1
System.out.println(array2D[1][2]); // Output: 6

3D Arrays

• A 3D array can be visualised as a multi-page spreadsheet and can also be thought of as multiple 2D arrays
• Selecting an element within a 3D array requires the following syntax to be used:
  • 3DArrayName[z, y, x]
• This is where z is the array index, y is the row index and x is the column index

Structure of a 3D array

Example in Pseudocode

// Define the dimensions of the 3D array
ROWS = 3
COLS = 4
DEPTH = 2

// Create a 3D array with the specified dimensions
array_3d = new Array[ROWS][COLS][DEPTH]

// Initialize the 3D array with values (optional)
for row = 0 to ROWS-1:
     for col = 0 to COLS-1:
         for depth = 0 to DEPTH-1:
             array_3d[row][col][depth] = initial_value

// Accessing elements in the 3D array
value = array_3d[row_index][col_index][depth_index]

Example in Python

# Method 1: Initialising an empty 3D array
rows = 3
cols = 4
depth = 2
array_3d = [[[0 for _ in range(depth)] for _ in range(cols)] for _ in range(rows)]
# The above code creates a 3D array with 3 rows, 4 columns, and 2 depths, filled with zeros.
 
# Method 2: Initialising a 3D array with values
array_3d = [[[1, 2], [3, 4], [5, 6], [7, 8]],
            [[9, 10], [11, 12], [13, 14], [15, 16]],
            [[17, 18], [19, 20], [21, 22], [23, 24]]]
# The above code creates a 3D array with the specified values.
 
# Accessing elements in the 3D array
print(array_3d[0][0][0])  # Output: 1
print(array_3d[1][2][1])  # Output: 14

Example in Java

// Method 1: Initialising an empty 3D array
int rows = 3;
int cols = 4;
int depth = 2;
int[][][] array3D = new int[rows][cols][depth];
// The above code creates a 3D array with 3 rows, 4 columns, and 2 depths, filled with zeros.
 
// Method 2: Initialising a 3D array with values
int[][][] array3D = { { {1, 2}, {3, 4}, {5, 6}, {7, 8} },
                       { {9, 10}, {11, 12}, {13, 14}, {15, 16} },
                       { {17, 18}, {19, 20}, {21, 22}, {23, 24} } };
// The above code creates a 3D array with the specified values.
 
// Accessing elements in the 3D array
System.out.println(array3D[0][0][0]);  // Output: 1
System.out.println(array3D[1][2][1]);  // Output: 14