Chapter 2

Arrays and Structures

Yi-Fen Liu
Department of IECS, FCU

References:
- E. Horowitz, S. Sahni and S. Anderson-Freed, Fundamentals of Data Structures (2nd Edition)
- Slides are credited from Prof. Chung, NTHU
 Outline
• The array as an Abstract Data Type
• Structures and Unions
• The polynomial Abstract Data Type
• The Sparse Matrix Abstract Data Type
• The Representation of Multidimensional Arrays
• String Matching

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 2

THE ARRAY AS AN ADT
 The array as an ADT (1)
• Arrays
– A set of pairs, <index, value>
– Data structure
• For each index, there is a value associated with that
index.
– Representation (possible)
• Implemented by using consecutive memory.
• In mathematical terms, we call this a correspondence or
a mapping.

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 4

 The array as an ADT (2)
• When considering an ADT we are more
concerned with the operations that can be
performed on an array.
– Aside from creating a new array, most languages
provide only two standard operations for arrays, one
that retrieves a value, and a second that stores a value.
– The advantage of this ADT definition is that it clearly
points out the fact that the array is a more general
structure than “a consecutive set of memory
locations.”

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 5

The array as an ADT (3)
 The array as an ADT (4)
• Arrays in C
– int list[5], *plist[5];
– list[5]: (five integers)
• list[0], list[1], list[2], list[3], list[4]  list
– *plist[5]: (five pointers to integers)
• plist[0], plist[1], plist[2], plist[3], plist[4]
– implementation of 1-D array
list[0] base address = 
list[1]  + sizeof(int)
list[2]  + 2*sizeof(int)
list[3]  + 3*sizeof(int) plist
list[4]  + 4*sizeof(int)
 The array as an ADT (5)
– Compare int *list1 and int list2[5] in C.
Same: list1 and list2 are pointers list1
Difference: list2 reserves five locations
– Notations list2
list2 － a pointer to list2[0]
(list2 + i) － a pointer to list2[i] (&list2[i])
*(list2 + i) － list2[i]
 Example Address Contents
1228 0
1230 1
• 1-dimension array addressing 1232 2
– int one[] = {0, 1, 2, 3, 4}; 1234 3
1236 4
– Goal: print out address and value
void print1(int *ptr, int rows) {
/* print out a one-dimensional array using a pointer */
int i;
printf(“Address Contents\n”);
for (i=0; i < rows; i++)
printf(“%8u%5d\n”, ptr+i,
*(ptr+i) );
printf(“\n”);
}

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 9

STRUCTURES AND UNIONS
 Structures and Unions (1)
• Structures (Records)
– Arrays are collections of data of the same type
– In C there is an alternate way of grouping data that
permit the data to vary in type
• This mechanism is called the struct, short for structure
– A structure is a collection of data items, where
each item is identified as to its type and name
 Structures and Unions (2)
• Create structure data type
– We can create our own structure data types by using
the typedef statement as below

• This says that human_being is the name of the type defined

by the structure definition, and we may follow this definition
with declarations of variables such as:
human_being person1, person2;
 Structures and Unions (3)
• We can also embed a structure within a structure.
Memory Layout

Memory Layout char name[10]

int month int age
int day date human_being float salary
int year int month
date int day
int year
Padding [2]
– A person born on February 11, 1994, would have
values for the date struct set as
 Structures and Unions (4)
• Unions
– A union declaration is similar to a structure
– The fields of a union must share their memory space
– Only one field of the union is “active” at any given time
Memory Layout
sex_type
enum tag_field
u int children int beard

person1.sex_info.sex = male;
person1.sex_info.u.beard = FALSE;
and
person2.sex_info.sex = female;
person2.sex_info.u.children = 4;
 Structures and Unions (5)
• Internal implementation of structures
– The fields of a structure in memory will be stored in
the same way using increasing address locations in the
order specified in the structure definition
– Holes or padding may actually occur
• Within a structure to permit two consecutive components to
be properly aligned within memory
– The size of an object of a struct or union type is the
amount of storage necessary to represent the largest
component, including any padding that may be
required

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 15

 Structures and Unions (6)
• Self-Referential Structures
– One or more of its components is a pointer to itself
– typedef struct list {
char data;
list *link;
}
– list item1, item2, item3; Construct a list with three nodes
item1.data=‘a’; item1.link=&item2;
item2.data=‘b’; item2.link=&item3;
item3.data=‘c’; malloc: obtain a node (memory)
item1.link=&item2;
item2.link=&item3; free: release memory
item3.link=NULL;
a b c
THE POLYNOMIAL ADT
 Ordered or Linear List
• Examples
– Ordered (linear) list: (item1, item2, item3, …, itemn)
• (Sunday, Monday, Tuesday, Wednesday, Thursday,
Friday, Saturday)
• (Ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, King)
• (basement, lobby, mezzanine, first, second)
• (1941, 1942, 1943, 1944, 1945)
• (a1, a2, a3, …, an-1, an)

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 18

 Operations on Ordered List
• Operations
– Finding the length, n , of the list.
– Reading the items from left to right (or right to left).
– Retrieving the i’th element.
– Storing a new value into the i’th position.
– Inserting a new element at the position i , causing
elements numbered i, i+1, …, n to become numbered
i+1, i+2, …, n+1
– Deleting the element at position i , causing elements
numbered i+1, …, n to become numbered i, i+1, …, n-1

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 19

 The Polynomial
• Polynomial examples
– Two example polynomials are
• A(x) = 3x20+2x5+4
• B(x) = x4+10x3+3x2+1
– Assume that we have two polynomials,
A(x) = aixi and B(x) = bixi where x is the variable,
ai is the coefficient, and i is the exponent, then
• A(x) + B(x) = (ai + bi)xi
• A(x) ·B(x) = (aixi ·(bjxj))
• Similarly, we can define subtraction and division on
polynomials, as well as many other operations

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 20

• An ADT
Definition
of a
Polynomial
 Polynomial Addition (1)
• A(x) = 3x20+2x5+4 and B(x) = x4+10x3+3x2+1
• D(x) = A(x) + B(x)
x20 x6 x5 x4 x3 x2 x1 x0
Lead_Exp()

A(x) 3 2 4
B(x) 1 10 3 1
Lead_Exp()

D(x)

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 22

 Polynomial Addition (2)
– /* d =a + b, where a, b, and d are polynomials */
d = Zero( )
while (! IsZero(a) && ! IsZero(b)) do {
switch ( COMPARE (Lead_Exp(a), Lead_Exp(b) ) {
case -1: d =
Attach(d, Coef (b, Lead_Exp(b)), Lead_Exp(b));
b = Remove(b, Lead_Exp(b));
break;
case 0: sum = Coef (a, Lead_Exp (a)) + Coef ( b, Lead_Exp(b));
if (sum) {
Attach (d, sum, Lead_Exp(a));
a = Remove(a , Lead_Exp(a)); advantage: easy implementation
b = Remove(b , Lead_Exp(b));
}
disadvantage: waste space when sparse
break;
case 1: d =
Attach(d, Coef (a, Lead_Exp(a)), Lead_Exp(a));
a = Remove(a, Lead_Exp(a));
}
}
– Insert any remaining terms of a or b into d
 The Polynomial ADT (1)
• There are two ways to create the type polynomial in C
– Representation I
• #define MAX_degree 101
/*MAX degree of polynomial+1*/
typedef struct{
int degree; Drawback: The first
float coef[MAX_degree]; representation may
} polynomial; waste space.
– Representation II
• #define MAX_TERMS 100
/*size of terms array*/
typedef struct{
float coef;
int expon;
} polynomial;
polynomial terms[MAX_TERMS];
int avail = 0; Use one global array to store all
polynomials

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 24

 The Polynomial ADT (2)
• Use one global array to store all polynomials
– The figure shows how these polynomials are
stored in the array terms.
specification representation
poly <start, finish>
A <0,1>
B <2,5>
A(x) = 2x1000+1 B(x) = x4+10x3+3x2+1
 The Polynomial ADT (3)
• A C function that adds two
polynomials,
A and B, represented as
above to obtain
D = A + B.
– To produce D(x), padd adds
A(x) and B(x) term by term.

Analysis: O(n+m)
where n (m) is the number
of nonzeros in A (B).
A(x) = 2x10001000+1

A(x)
B(x) = 2x
x44+10x
1000+1
1000 33+3x22+1
coeffieicent = 33
B(x)
starta= =
++
x441
2
0+10x
;finisha+3x=22+1
1
term[starta] + term [startb] =
term[starta].expon
startb++
startb
starta =++56
2
3
4;;finishb = =5 01000 <
==
> >
2
term[startb].
startb
starta
term[startb].expon
=
<=5;
1;
2;
4;
3;finisha
expon = TRUE
FALSE
== 43
0
2
4
startb <=
= 6;finishb = TRUEFALSE

Term
2x1000
1
x4
10x3
3x2
1
2x1000
x4
10x3
3x2
2
 The Polynomial ADT (5)
Problem: Compaction is required
when polynomials that are no longer needed.
(data movement takes time)

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 28

THE SPARSE MATRIX ADT
 The Sparse Matrix (1)
• In mathematics, a matrix contains m rows and
n columns of elements, we write mn to
designate a matrix with m rows and n columns.

5*3 6*6
15/15 8/36

Sparse Matrix
 The Sparse Matrix (2)
• The standard representation of a matrix is a two
dimensional array defined as
a[MAX_ROWS][MAX_COLS]
– We can locate quickly any element by writing a[i][j]
• Sparse matrix wastes space
– We must consider alternate forms of representation
– Our representation of sparse matrices should store
only nonzero elements
– Each element is characterized by <row, col, value>

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 31

 The Sparse Matrix ADT (1)
• A minimal set of
operations
– Matrix creation
– Addition
– Multiplication
– Transpose
 The Sparse Matrix ADT (2)
• The Create operation

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 33

 The Sparse Matrix ADT (3)
• Represented by a two-dimensional array
• Each element is characterized by <row, col, value>
• row, column in ascending order

# of rows (columns) # of nonzero terms

transpose
 Transpose a Matrix
• For each row i
– take element <i, j, value> and store it in element <j, i,
value> of the transpose
– difficulty: where to put <j, i, value>
(0, 0, 15) ====> (0, 0, 15)
(0, 3, 22) ====> (3, 0, 22)
(0, 5, -15) ====> (5, 0, -15)
(1, 1, 11) ====> (1, 1, 11)
Move elements down very often
• For all elements in column j,
– place element <i, j, value> in element <j, i, value>

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 35

 Transpose a Matrix

For all column i in a

For all element j in a

==> O(columns*elements)
 Discussion
• Compared with 2-D array representation
– O(columns*elements) v.s. O(columns*rows)
– elements --> columns * rows when non-sparse,
O(columns2*rows)
• Problem: Scan the array “columns” times
– In fact, we can transpose a matrix represented as a
sequence of triples in O(columns + elements) time
• Solution
– First, determine the number of elements
in each column of the original matrix
– Second, determine the starting positions of each row
in the transpose matrix

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 37

 Fast Transpose of a Sparse Matrix (1)
row col value row col value
a[0] 6 6 8 b[0] 6 6 8
a[1] 0 0 15 b[1] 0 0 15
a[2] 0 3 22 b[2] 0 4 91
a[3] 0 5 -15 b[3] 1 1 11
a[4] 1 1 11 b[4] 2 1 3
a[5] 1 2 3 b[5] 2 5 28
a[6] 2 3 -6 b[6] 3 0 22
a[7] 4 0 91 b[7] 3 2 -6
a[8] 5 2 28 b[8] 5 0 -15

 How to predict the location?

 First, determine the number of elements
in each column of the original matrix
 Second, determine the starting positions of each row
in the transpose matrix
Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 38
 Fast Transpose of a Sparse Matrix (2)
row col value [0] [1] [2] [3] [4] [5]
a[0] 6 6 8 row_terms 2 0
1 0
1 0
1
2 0
2
1 0 0
1
a[1] 0 0 15 starting_pos 1 3 4 6 8 8
a[2] 0 3 22
a[3] 0 5 -15
a[4] 1 1 11 Determine the number of elements in each column
a[5] 1 2 3
a[6] 2 3 -6
a[7] 4 0 91
a[8] 5 2 28

Determine the starting positions of each row

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 39

Fast Transpose of a Sparse Matrix (3)
[0] [1] [2] [3] [4] [5]
starting_pos 3
1
2 3
4 4
5
6 6
7
8 8 8
9

row col value row col value

a[0] 6 6 8 b[0] 6 6 8
a[1] 0 0 15 b[1]
a[2] 03 30 22 b[2]
a[3] 0
5 5
0 -15 b[3]
a[4] 1 1 11 b[4]
a[5] 12 21 3 b[5]
a[6] 3
2 2
3 -6 b[6]
a[7] 40 04 91 b[7]
a[8] 52 25 28 b[8]
Fast Transpose of a Sparse Matrix (4)
 Matrix Multiplication
• Definition
– Given A and B where A is mn and B is np, the
product matrix D has dimension mp. Its <i, j>
element is n 1
d ij   aikbkj
k 0
for 0  i < m and 0  j < p.
• Example

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 42

 Sparse Matrix Multiplication (1)
• Definition
– [D]m  p= [A]m  n  [B]n  p
• Procedure
– Fix a row of A and find all elements in column j of B for j = 0, 1, …, p-1.
• Alternative 1
– Scan all of B to find all elements in j
• Alternative 2
– Compute the transpose of B
(Put all column elements consecutively)
– Once we have located the elements of row i of A and column j of B we
just do a merge operation similar to that used in the polynomial
addition

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 43

 Sparse Matrix Multiplication (2)
• General case
– dij=ai0*b0j+ai1*b1j+…+ai(n-1)*b(n-1)j
– Array A is grouped by i, and after transpose,
array B is also grouped by j

a a0* d b*0
b a1* e b*1
c a2* f b*2
g b*3

The multiply operation generate entries:

a*d , a*e , a*f , a*g , b*d , b*e , b*f , b*g , c*d , c*e , c*f , c*g

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 44

 Sparse Matrix Multiplication (3)

3 -1 0 3 0 2
1 0 2 3 0 12
A= BT = 0 0 0 B= -1 0 0 A ×B =
-1 4 6 -7 0 28
2 0 5 0 0 5

row col value row col value row col value

A[0] 2 3 5 BT[0] 3 3 4 D[0] 2 3 ?
A[1] 0 0 1 BT[1] 0 0 3 D[1] 0 0 3
A[2] 0 2 2 BT[2] 0 1 -1 D[2] 0 2 12
A[3] 1 0 -1 BT[3] 2 0 2 D[3] 1 0 -7
A[4] 1 1 4 BT[4] 2 2 5 D[4] 1 2 28
A[5] 1 2 6

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 45

 Sparse Matrix Multiplication (4)
3 -1 0 3 0 2
1 0 2 3 0 12
A= BT = 0 0 0 B= -1 0 0 A ×B =
-1 4 6 -7 0 28
2 0 5 0 0 5

row = A[1].row column = BT[1].row sum==00

sum 3
row col value row col value row col value
A[0] 2 3 5 BT[0] 3 3 4 totald D[0] ? ? ?
i A[1] 0 0 1 j BT[1] 0 0 3 D[1] 0 0 3
i A[2] 0 2 2 j BT[2] 0 1 -1
A[3] 1 0 -1 j BT[3] 2 0 2
A[4] 1 1 4 BT[4] 2 2 5
A[5] 1 2 6
if (A[i].col = BT[j].col) i = 1, j = 1, sum += 1 × 3
T
(sum += A[i++].value * B [j++].value ); i = 2, j = 2, j++;
T
else if (A[i].col < B [j].col) i = 2, j = 3, BT[j].row != column
i ++; storesum()
else Reset sum, i and column
j++;
 Sparse Matrix Multiplication (5)
3 -1 0 3 0 2
1 0 2 3 0 12
A= BT = 0 0 0 B= -1 0 0 A ×B =
-1 4 6 -7 0 28
2 0 5 0 0 5

row = A[i].row column = BT[j].row sum===00312

sum
sum 2
row col value row col value row col value
A[0] 2 3 5 BT[0] 3 3 4 D[0] ? ? ?
i A[1] 0 0 1 BT[1] 0 0 3 totald D[1] 0 0 3
i A[2] 0 2 2 BT[2] 0 1 -1 D[2] 0 2 12
i A[3] 1 0 -1 j BT[3] 2 0 2
A[4] 1 1 4 j BT[4] 2 2 5
A[5] 1 2 6 j BT[5] ??
if (A[i].col = BT[j].col) i = 1, j = 3, sum += 1 × 2
(sum += A[i++].value * BT[j++].value ); i = 2, j = 4, sum += 2 × 5
else if (A[i].col < BT[j].col) i = 3, j = 5, A[i].row != row
i ++; storesum()
else Reset sum, i and column
j++;
Sparse Matrix Multiplication (6)
 Sparse Matrix Multiplication (7)

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 49

 Analyzing The Algorithm (1)
• cols_b * termsrow1 + totalb +
cols_b * termsrow2 + totalb +
…+
cols_b * termsrowp + totalb
= cols_b * (termsrow1 + termsrow2 + … + termsrowp)
+ rows_a * totalb
= cols_b * totala + rows_a * totalb

O(cols_b * totala + rows_a * totalb)

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 50

 Analyzing The Algorithm (2)
• Compared with matrix multiplication using
array
– for (i =0; i < rows_a; i++)
for (j=0; j < cols_b; j++) {
sum =0;
for (k=0; k < cols_a; k++)
sum += (a[i][k] *b[k][j]);
d[i][j] =sum;
}
– O(rows_a * cols_a * cols_b) v.s.
O(cols_b * total_a + rows_a * total_b)

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 51

 Analyzing The Algorithm (3)
• Optimal case
total_a < rows_a * cols_a
total_b < cols_a * cols_b
• Worse case
total_a --> rows_a * cols_a, or
total_b --> cols_a * cols_b

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 52

THE REPRESENTATION OF
MULTIDIMENSIONAL ARRAYS
 Multidimensional Arrays (1)
• If an array is declared
a[upper0][upper1]…[uppern-1],
then it is easy to see that the number of
elements in the array is
n 1

 upper
i 0
i

– Where Π is the product of the upperi’s.

– Example
• If we declare a as a[10][10][10], then we require
10*10*10 = 1000 units of storage to hold the array
Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 54
 Multidimensional Arrays (2)
• Represent multidimensional arrays
– row major order and column major order
• Row major order stores multidimensional
arrays by rows
– A[upper0][upper1] as
upper0 rows: row0, row1, …, rowupper0-1,
each row containing upper1 elements

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 55

 Multidimensional Arrays (3)
• Row major order: A[i][j] :  + i × upper1 + j
• Column major order: A[i][j] :  + j × upper0 + i

col0 col1 colu1-1

row0 A[0][0] A[0][1] A[0][u1-1]
α α+1 α+(u1-1)
row1 A[1][0] A[1][1] A[1][u1-1]
α+u1 α+u1+1 α+2u1-1

rowu0-1 A[u0-1][0] A[u0-1][1] A[u0-1][u1-1]

α+(u0-1)u1 α+(u0-1)u1+1 α +u0u1-1

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 56

 Multidimensional Arrays (4)
• To represent a three-dimensional array,
A[upper0][upper1][upper2], we interpret the array
as upper0 two-dimensional arrays of dimension
upper1upper2
– To locate a[i][j][k], we first obtain  + i  upper1 
upper2 as the address of a[i][0][0] because there are i
two dimensional arrays of size upper1  upper2
preceding this element
 + i  upper1  upper2+ j  upper2+k
as the address of a[i][j][k]

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 57

 Multidimensional Arrays (5)
• Generalizing on the preceding discussion, we can
obtain the addressing formula for any element
A[i0][i1]…[in-1] in an n-dimensional array declared
as
A[upper0][upper1]…[uppern-1]
– The address for A[i0][i1]…[in-1] is
STRING MATCHING
 Knuth, Morris, Pratt Pattern
Matching Algorithm (1)
string abababbababaabb
pattern ababbababaa
ababbababaa

• Failure function
– If p = p0p1…pn-1 is a pattern, then its failure function, f, is defined as:

largest i  j such that p0 p1... pi  p j i p j i 1... p j if such an i  0 exists

f ( j)  
  1 otherwise

  1 if j  0

f ( j )   f m ( j  1)  1 where m is the least integer k for which p f k ( j 1) 1  p j
 - 1 if there is no k satisfying the above

 Knuth, Morris, Pratt Pattern
Matching Algorithm (2)
i 0 1 2 3 4 5 6 7 8 9 10
a b a b b a b a b a a
f -1 -1 0 1 -1 0 1 2 3 2

j
void fail(char *pat)
{
int n = strlen(pat); j=9
failure[0] = -1; i = failure[9-1] = 3
pat[j] != pat[i+1]
for ( j = 1; j < n; j++) {
i = failure[3] = 1
i = failure[ j-1]; pat[j] = pat[i+1]
while ((pat[ j] != pat[i+1] && (i >= 0)) failure[j] = i+1=2
i = failure[i];
if (pat[ j] == pat[i+1])
failure[ j] = i+1;
else failure[ j] = -1;
}
}
 Knuth, Morris, Pratt Pattern
Matching Algorithm (3)
i 0 1 2 3 4 5 6 7 8 9 10
a b a b b a b a b a a
f -1 -1 0 1 -1 0 1 2 3

string abababbababaabb
pattern ababbababaa
ababbababaa

j = failure[j-1]+1=1+1=2

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 62

 Knuth, Morris, Pratt Pattern
Matching Algorithm (4)
int pmatch(char *string, char *pat)
{
int i = 0, j = 0;
int lens = strlen(string);
int lenp = strlen(pat);
while ( i < lens && j < lenp ) {
if (string[i] == pat[j]) {
i++;
j++;
} else if (j == 0)
i++;
else
j = failure[j-1]+1;
}
return ( (j == lenp) ? (i-lenp) : -1);
}

Yi-Fen Liu, FCU IECS Data Structures (Ch2) - 63