Notes on Arrays
### Definition
**Array**: An array is a collection of items stored at contiguous memory locations. The idea is to
store multiple items of the same type together. This makes it easier to calculate the position of each
element by simply adding an offset to a base value, i.e., the memory location of the first element of
the array (generally denoted by the name of the array).
### Single and Multidimensional Arrays
**Single Dimensional Array (1-D Array)**: A list of items can be given a single index number to
identify an element within the array.
Example:
```c
int arr[5] = {1, 2, 3, 4, 5};
```
**Multidimensional Array**: An array of arrays. For example, a two-dimensional array in C can be
defined as an array of arrays.
**Two Dimensional Array (2-D Array)**: It is often visualized as a table (matrix) with rows and
columns.
Example:
```c
int arr[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
```
### Representation of Arrays
**Row Major Order**: In row-major order, the consecutive elements of the rows of the array are
contiguous in memory. This is the default in languages like C and Python.
**Column Major Order**: In column-major order, the consecutive elements of the columns of the
array are contiguous in memory. This is common in languages like Fortran.
### Derivation of Index Formulae
**1-D Array**:
For an array `arr` with base address `base` and element size `w` (in bytes), the address of the
element `arr[i]` is calculated as:
\[ ext{Address} = ext{base} + i imes w \]
**2-D Array (Row Major Order)**:
For a 2-D array `arr` with `m` rows and `n` columns, and base address `base`, the address of the
element `arr[i][j]` is calculated as:
\[ ext{Address} = ext{base} + (i imes n + j) imes w \]
**2-D Array (Column Major Order)**:
For a 2-D array `arr` with `m` rows and `n` columns, and base address `base`, the address of the
element `arr[i][j]` is calculated as:
\[ ext{Address} = ext{base} + (j imes m + i) imes w \]
### Applications of Arrays
- **Storing Data**: Arrays are used to store multiple data items of the same type.
- **Matrices**: In scientific computing and graphics, arrays are used to represent matrices.
- **Database Records**: Arrays are used to store records in databases.
- **Static Lookup Tables**: Arrays are used in algorithms to create static lookup tables.
### Sparse Matrices and Their Representations
**Sparse Matrix**: A sparse matrix is a matrix in which most of the elements are zero. Efficient
storage and operations on sparse matrices are crucial for performance in many applications.
**Representations of Sparse Matrices**:
1. **Array Representation**: Use a 1-D or 2-D array but this is inefficient due to many zero elements.
2. **List of Lists (LoL)**: Each row of the matrix is represented as a list of column indices and
values. This is a more space-efficient representation.
3. **Compressed Sparse Row (CSR)**: This representation uses three arrays to store non-zero
elements and their row and column indices.
- `values`: Stores non-zero elements.
- `col_index`: Stores the column index of each non-zero element.
- `row_pointer`: Stores the index in `values` where the row starts.
4. **Compressed Sparse Column (CSC)**: Similar to CSR but stores columns instead of rows.
- `values`: Stores non-zero elements.
- `row_index`: Stores the row index of each non-zero element.
- `col_pointer`: Stores the index in `values` where the column starts.
#### Example of CSR Representation:
Consider the matrix:
```
003
100
020
```
- `values`: [3, 1, 2]
- `col_index`: [2, 0, 1]
- `row_pointer`: [0, 1, 2, 3]
This concise representation significantly reduces the memory footprint for sparse matrices.
