Arrays and Matrices
CSE, POSTECH
Introduction
Data is often available in tabular form
Tabular data is often represented in arrays
Matrix is an example of tabular data and is often
represented as a 2-dimensional array
– Matrices are normally indexed beginning at 1 rather
than 0
– Matrices also support operations such as add, multiply,
and transpose, which are NOT supported by C++’s 2D
array
2
Introduction
It is possible to reduce time and space using a
customized representation of multidimensional
arrays
This chapter focuses on
– Row- and column-major mapping and representations of
multidimensional arrays
– the class Matrix
– Special matrices
Diagonal, tridiagonal, triangular, symmetric, sparse
3
1D Array Representation in C++
Memory
a b c d
start
1-dimensional array x = [a, b, c, d]
map into contiguous memory locations
location(x[i]) = start + i
Space Overhead
Memory
a b c d
start
space overhead = 4 bytes for start
(excludes space needed for the elements of x)
2D Arrays
The elements of a 2-dimensional array a declared as:
int a[3][4];
may be shown as a table
a[0][0] a[0][1] a[0][2] a[0][3]
a[1][0] a[1][1] a[1][2] a[1][3]
a[2][0] a[2][1] a[2][2] a[2][3]
Rows of a 2D Array
a[0][0] a[0][1] a[0][2] a[0][3] row 0
a[1][0] a[1][1] a[1][2] a[1][3] row 1
a[2][0] a[2][1] a[2][2] a[2][3] row 2
Columns of a 2D Array
a[0][0] a[0][1] a[0][2] a[0][3]
a[1][0] a[1][1] a[1][2] a[1][3]
a[2][0] a[2][1] a[2][2] a[2][3]
column 0 column 1 column 2 column 3
2D Array Representation in C++
2-dimensional array x
a, b, c, d
e, f, g, h
i, j, k, l
view 2D array as a 1D array of rows
x = [row0, row1, row 2]
row 0 = [a, b, c, d]
row 1 = [e, f, g, h]
row 2 = [i, j, k, l]
and store as 4 1D arrays
2D Array Representation in C++
x[]
a b c d
4 separate
e f g h
1-dimensional arrays
i j k l
space overhead = overhead for 4 1D arrays
= 4 * 4 bytes
= 16 bytes
= (number of rows + 1) x 4 bytes
Array Representation in C++
x[]
a b c d
e f g h
i j k l
This representation is called the array-of-arrays
representation.
Requires contiguous memory of size 3, 4, 4, and 4 for the 4
1D arrays.
1 memory block of size number of rows and number of rows
blocks of size number of columns
Row-Major Mapping
Example 3 x 4 array:
abcd
efgh
i jkl
Convert into 1D array y by collecting elements by rows.
Within a row elements are collected from left to right.
Rows are collected from top to bottom.
We get y[] = {a, b, c, d, e, f, g, h, i, j, k, l}
row 0 row 1 row 2 … row i
Locating Element x[i][j]
0 c 2c 3c ic
row 0 row 1 row 2 … row i
assume x has r rows and c columns
each row has c elements
i rows to the left of row i
so ic elements to the left of x[i][0]
x[i][j] is mapped to position
ic + j of the 1D array
Space Overhead
row 0 row 1 row 2 … row i
4 bytes for start of 1D array +
4 bytes for c (number of columns)
= 8 bytes
Note that we need contiguous memory of size rc.
Column-Major Mapping
abcd
efgh
i jkl
Convert into 1D array y by collecting elements by columns.
Within a column elements are collected from top to
bottom.
Columns are collected from left to right.
We get y = {a, e, i, b, f, j, c, g, k, d, h, l}
Row- and Column-Major Mappings
2D Array int a[3][6];
a[0][0] a[0][1] a[0][2] a[0][3] a[0][4] a[0][5]
a[1][0] a[1][1] a[1][2] a[1][3] a[1][4] a[1][5]
a[2][0] a[2][1] a[2][2] a[2][3] a[2][4] a[2][5]
16
Row- and Column-Major Mappings
Row-major order mapping functions
map(i1,i2) = i1u2+i2 for 2D arrays
map(i1,i2,i3) = i1u2u3+i2u3+i3 for 3D arrays
What is the mapping function for Figure 7.2(a)?
map(i1,i2) = 6i1+i2
map(2,3) = ?
Column-major order mapping functions
// do this as an exercise
17
Irregular 2D Arrays
x[]
2 3
4 5 6
7 8 9 l0
Irregular 2-D array: the length of rows is not required
to be the same.
Creating and Using Irregular 2D Arrays
// declare a two-dimensional array variable
// and allocate the desired number of rows
int ** irregularArray = new int*[numberOfRows];
// now allocate space for elements in each row
for (int i = 0; i < numberOfRows; i++)
irregularArray[i] = new int [length[i]];
// use the array like any regular array
irregularArray[2][3] = 5;
irregularArray[4][6] = irregularArray[2][3]+2;
irregularArray[1][1] += 3;
Matrices
m x n matrix is a table with m rows and n columns.
M(i,j) denotes the element in row i and column j.
Common matrix operations
– transpose
– addition
– multiplication
20
Matrix Operations
Transpose
– The result of transposing an m x n matrix is an n x m
matrix with property:
MT(j,i) = M(i,j), 1 <= i <= m, 1 <= j <= n
Addition
– The sum of matrices is only defined for matrices that
have the same dimensions.
– The sum of two m x n matrices A and B is an m x n
matrix with the property:
C(i,j) = A(i,j) + B(i,j), 1 <= i <= m, 1 <= j <= n
21
Matrix Operations
Multiplication
– The product of matrices A and B is only defined when
the number of columns in A is equal to the number of
rows in B.
– Let A be m x n matrix and B be a n x q matrix. A*B will
produce an m x q matrix with the following property:
C(i,j) = Σ(k=1…n) A(i,k) * B(k,j)
where 1 <= i <= m and 1 <= j <= q
Read Example 7.2
22
A Matrix Class
There are many possible implementations for
matrices.
// use a built-in 2 dimensional array
T matrix[m][n]
// use the Array2D class
Array2D<T> matrix(m,n)
// or flatten the matrix into a one-dimensional array
template<class T>
class Matrix {
private: int rows, columns;
T *data;
};
23
Shortcomings of using a 2D Array for a Matrix
Indexes are off by 1.
C++ arrays do not support matrix operations such
as add, transpose, multiply, and so on.
– Suppose that x and y are 2D arrays. Cannot do x + y,
x –y, x * y, etc. in C++.
We need to develop a class matrix for object-
oriented support of all matrix operations.
See Programs 7.2-7.7
Read Sections 7.1-7.2
24
