CHAPTER 2

ARRAYS AND STRUCTURES

All the programs in this file are selected from
Ellis Horowitz, Sartaj Sahni, and Susan Anderson-Freed
“Fundamentals of Data Structures in C”,

CHAPTER 2 1
 Arrays
Array: a set of index and value

data structure
For each index, there is a value associated with
that index.

representation (possible)
implemented by using consecutive memory.

CHAPTER 2 2
 objects: A set of pairs <index, value> where for each value of index
there is a value from the set item. Index is a finite ordered set of one or

more dimensions, for example, {0, … , n-1} for one dimension,

{(0,0),(0,1),(0,2),(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)} for two dimensions,

etc.
Functions:
for all A  Array, i  index, x  item, j, size  integer
Array Create(j, list) ::= return an array of j dimensions where list is a

j-tuple whose ith element is the size of the

ith dimension. Items are undefined.

Item Retrieve(A, i) ::= if (i  index) return the item associated with
index value i in array A
else return error
Array Store(A, i, x) ::= if (i in index)
return an array that is identical to array
A except the new pair <i, x> has been
inserted else return error
CHAPTER 2 3
end array
 Arrays in C
int list[5], *plist[5];

list[5]: five integers

list[0], list[1], list[2], list[3], list[4]
*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)
list[4]  + 4*size(int)
CHAPTER 2 4
 Arrays in C (Continued)
Compare int *list1 and int list2[5] in C.

Same: list1 and list2 are pointers.

Difference: list2 reserves five locations.

Notations:
list2 - a pointer to list2[0]
(list2 + i) - a pointer to list2[i] (&list2[i])
*(list2 + i) - list2[i]

CHAPTER 2 5
Example: 1-dimension array addressing
int one[] = {0, 1, 2, 3, 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”);
}

CHAPTER 2 6
call print1(&one[0], 5)

Address Contents
1228 0
1230 1
1232 2
1234 3
1236 4
*Figure 2.1: One- dimensional array addressing (p.53)

CHAPTER 2 7
Structures (records)
struct {
char name[10];
int age;
float salary;
} person;

strcpy(person.name, “james”);
person.age=10;
person.salary=35000;

CHAPTER 2 8
Create structure data type
typedef struct human_being {
char name[10];
int age;
float salary;
};

or

typedef struct {
char name[10];
int age;
float salary
} human_being;

human_being person1, person2;

CHAPTER 2 9
 Unions ( 不考 )
Similar to struct, but only one field is active.
Example: Add fields for male and female.
typedef struct sex_type {
enum tag_field {female, male} sex;
union {
int children;
int beard;
} u;
};
typedef struct human_being {
char name[10]; human_being person1, person2;
int age; person1.sex_info.sex=male;
float salary; person1.sex_info.u.beard=FALSE;
date dob;
sex_type sex_info;
} CHAPTER 2 10
 Self-Referential Structures
One or more of its components is a pointer to itself.

typedef struct list Construct

{ a list with three nodes
char data; item1.link=&item2;
list *link; item2.link=&item3;
} malloc: obtain a node

list item1, item2, item3;

item1.data=‘a’; a b c
item2.data=‘b’;
item3.data=‘c’;
item1.link=item2.link=item3.link=NULL;
CHAPTER 2 11
 Polynomials A(X)=3X20+2X5+4, B(X)=X4+10X3+3X2+1
Structure Polynomial is ( 不考 )
objects:
p( x ) a1 x e1  ...  an x en ; a set of ordered pairs of
<ei,ai> where ai in Coefficients and ei in Exponents, ei are integers >= 0
functions:
for all poly, poly1, poly2  Polynomial, coef Coefficients, expon
Exponents
Polynomial Zero( ) ::= return the polynomial,
p(x) = 0
Boolean IsZero(poly) ::= if (poly) return FALSE
else return TRUE
Coefficient Coef(poly, expon) ::= if (expon  poly) return its
coefficient else return Zero
Exponent Lead_Exp(poly) ::= return the largest exponent in
poly
Polynomial Attach(poly,coef, expon) ::= if (expon  poly) return error
else return the polynomial poly

with the term <coef, expon>

inserted
CHAPTER 2 12
Polynomial Remove(poly, expon) ::= if (expon  poly) return the
polynomial poly with the
term whose exponent is
expon deleted
else return error
Polynomial SingleMult(poly, coef, expon) ::= return the polynomial
poly • coef • xexpon
Polynomial Add(poly1, poly2) ::= return the polynomial
poly1 +poly2
Polynomial Mult(poly1, poly2) ::= return the polynomial
poly1 • poly2

End Polynomial
*Structure 2.2:Abstract data type Polynomial (p.61)

CHAPTER 2 13
 Polynomial Addition
data structure 1: #define MAX_DEGREE 101
typedef struct {
int degree;
float coef[MAX_DEGREE];
} polynomial;
/* 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!=0) {
Attach (d, sum, Lead_Exp(a));
a = Remove(a , Lead_Exp(a));
b = Remove(b , Lead_Exp(b));
} CHAPTER 2 14
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

advantage: easy implementation

disadvantage: waste space when sparse

*Program 2.4 :Initial version of padd function(p.62)

CHAPTER 2 15
Data structure 2: use one global array to store all polynomials
A(X)=2X1000+1
B(X)=X4+10X3+3X2+1 *Figure 2.2: Array representation of two polynomials
(p.63)
starta finisha startb finishb avail

coef
2 1 1 10 3 1

exp
1000 0 4 3 2 0

0 1 2 3 4 5 6

specification representation
poly <start, finish>
A CHAPTER 2 <0,1> 16
B <2,5>
 storage requirements: start, finish, 2*(finish-start+1)
nonparse: twice as much as (1)
when all the items are nonzero

MAX_TERMS 100 /* size of terms array */

typedef struct {
float coef;
int expon;
} polynomial;
polynomial terms[MAX_TERMS];
int avail = 0;
*(p.62)

CHAPTER 2 17
 Add two polynomials: D = A + B
void padd (int starta, int finisha, int startb, int finishb,
int * startd, int *finishd)
{
/* add A(x) and B(x) to obtain D(x) */
float coefficient;
*startd = avail;
while (starta <= finisha && startb <= finishb)
switch (COMPARE(terms[starta].expon,
terms[startb].expon)) {
case -1: /* a expon < b expon */
attach(terms[startb].coef, terms[startb].expon);
startb++
break;

CHAPTER 2 18
case 0: /* equal exponents */
coefficient = terms[starta].coef +
terms[startb].coef;
if (coefficient!=0)
attach (coefficient, terms[starta].expon);
starta++;
startb++;
break;
case 1: /* a expon > b expon */
attach(terms[starta].coef, terms[starta].expon);
starta++;
}

CHAPTER 2 19
/* add in remaining terms of A(x) */
for( ; starta <= finisha; starta++)
attach(terms[starta].coef, terms[starta].expon);
/* add in remaining terms of B(x) */
for( ; startb <= finishb; startb++)
attach(terms[startb].coef, terms[startb].expon);
*finishd =avail -1;
}
Analysis: O(n+m)
where n (m) is the number of nonzeros in A(B).
*Program 2.5: Function to add two polynomial (p.64)
CHAPTER 2 20
void attach(float coefficient, int exponent)
{
/* add a new term to the polynomial */
if (avail >= MAX_TERMS) {
fprintf(stderr, “Too many terms in the polynomial\n”);
exit(1);
}
terms[avail].coef = coefficient;
terms[avail++].expon = exponent;
}
*Program 2.6:Function to add anew term (p.65)

Problem: Compaction is required

when polynomials that are no longer needed.
(data movement takes time.)
CHAPTER 2 21
 Sparse Matrix

col0 col1 col2 col3 col4 col5

row0  15 0 0 22 0  15
row1
 0 11 3 0 0 0 
 
row2  0 0 0  6 0 0
 
row3  0 0 0 0 0 0 
row4
 91 0 0 0 0 0
 
row5  0 0 28 0 0 0
5*3 6*6
(a) 15/15 (b) 8/36

*Figure 2.3:Two matrices

sparse matrix
data structure?
CHAPTER 2 22
 SPARSE MATRIX ABSTRACT DATA TYPE
Structure Sparse_Matrix is ( 不考 )
objects: a set of triples, <row, column, value>, where row
and column are integers and form a unique combination, and
value comes from the set item.
functions:
for all a, b  Sparse_Matrix, x  item, i, j, max_col,
max_row  index

Sparse_Marix Create(max_row, max_col) ::=

return a Sparse_matrix that can hold up to
max_items = max _row  max_col and
whose maximum row size is max_row and

whose maximum column size is max_col.

CHAPTER 2 23
Sparse_Matrix Transpose(a) ::=
return the matrix produced by interchanging
the row and column value of every triple.
Sparse_Matrix Add(a, b) ::=
if the dimensions of a and b are the same
return the matrix produced by adding
corresponding items, namely those with
identical row and column values.
else return error
Sparse_Matrix Multiply(a, b) ::=
if number of columns in a equals number of
rows in b
return the matrix d produced by multiplying
a by b according to the formula: d [i] [j] =
(a[i][k]•b[k][j]) where d (i, j) is the (i,j)th
element
else return error.
CHAPTER 2 24
* Structure 2.3: Abstract data type Sparse-Matrix (p.68)
 (1) Represented by a two-dimensional array.
Sparse matrix wastes space.
(2) Each element is characterized by <row, col, value>.
row col value row col value
# of rows (columns)
# of nonzero terms
a[0] 6
6 8 b[0] 6 6 8
[1] 0
0 15 [1] 0 0 15
[2] 0
3 22 [2] 0 4 91
[3] 0
5 -15 [3] 1 1 11
[4] 1
1 11 transpose [4] 2 1 3
[5] 1
2 3 [5] 2 5 28
[6] 2
3 -6 [6] 3 0 22
[7] 4
0 91 [7] 3 2 -6
[8] 5
2 28 [8] 5 0 -15
(a) (b)
row, column in ascending order
*Figure 2.4:Sparse matrix and its transpose stored as triples (p.69)
CHAPTER 2 25
Sparse_matrix Create(max_row, max_col) ::=

#define MAX_TERMS 101 /* maximum number of terms +1*/

typedef struct {
int col; # of rows (columns)
int row; # of nonzero terms
int value;
} term;
term a[MAX_TERMS]

* (P.69)

CHAPTER 2 26
 Transpose a Matrix
(1) 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.

(2) Algorithm of Transposing a Matrix:

For all elements in column j,
place element <i, j, value> in element <j, i, value>
CHAPTER 2 27
void transpose (term a[], term b[])
/* b is set to the transpose of a */
{
int n, i, j, currentb;
n = a[0].value; /* total number of elements */
b[0].row = a[0].col; /* rows in b = columns in a */
b[0].col = a[0].row; /*columns in b = rows in a */
b[0].value = n;
if (n > 0) { /*non zero matrix */
currentb = 1;
for (i = 0; i < a[0].col; i++)
/* transpose by columns in a */
for( j = 1; j <= n; j++)
/* find elements from the current column */
if (a[j].col == i) {
/* element is in current column, add it to b */
CHAPTER 2 28
 columns

elements

b[currentb].row = a[j].col;
b[currentb].col = a[j].row;
b[currentb].value = a[j].value;
currentb++
}
}
}
* Program 2.7: Transpose of a sparse matrix (p.71)

Scan the array “columns” times. ==> O(columns*elements)

The array has “elements” elements.
CHAPTER 2 29
Discussion: compared with 2-D array representation

O(columns*elements) vs. O(columns*rows)

elements --> columns * rows when nonsparse

O(columns*columns*rows)

Problem: Scan the array “columns” times.

Solution:
Determine the number of elements in each column of
the original matrix.
==>
Determine the starting positions of each row in the
transpose matrix.
CHAPTER 2 30
 Fast Transpose a Matrix:

row column value row col. vlaue

a[0] 6 6 8 b[0] 6 6 8
[1] 0 0 15 [1] 0 0 15
[2] 0 3 22 [2] 0 4 91
[3] 0 5 -15 [3] 1 1 11
[4] 1 1 11 transpose [4] 2 1 3
[5] 1 2 3 [5] 2 5 28
[6] 2 3 -6 [6] 3 0 22
[7] 4 0 91 [7] 3 2 -6
[8] 5 2 28 [8] 5 0 -15
[0] [1] [2] [3] [4] [5]
row_terms = 2 1 2 2 0 1 [ 課本有誤 ]
starting_pos = 1 3 4 6 8 8
CHAPTER 2 31
 void fast_transpose(term a[ ], term b[ ])
{
/* the transpose of a is placed in b */
int row_terms[MAX_COL], starting_pos[MAX_COL];
int i, j, num_cols = a[0].col, num_terms = a[0].value;
b[0].row = num_cols; b[0].col = a[0].row;
b[0].value = num_terms;
if (num_terms > 0){ /*nonzero matrix*/
for (i = 0; i < num_cols; i++)
columns row_terms[i] = 0; // 設 b[] 每列元素個數為 0
for (i = 1; i <= num_terms; i++)
elements row_term [a[i].col]++; // 計算 b[] 每列的元素個數
starting_pos[0] = 1;
for (i =1; i < num_cols; i++) // 計算 b[] 每一列的起始位址
columns starting_pos[i]=starting_pos[i-1] +row_terms [i-
1];

CHAPTER 2 32
 for (i=1; i <= num_terms, i++) {
j = starting_pos[a[i].col]++;
elements b[j].row = a[i].col;
b[j].col = a[i].row;
b[j].value = a[i].value;
}
}
}
*Program 2.8:Fast transpose of a sparse matrix

Compared with 2-D array representation

O(columns+elements) vs. O(columns*rows)
elements --> columns * rows
O(columns+elements) --> O(columns*rows)

Cost: Additional row_terms and starting_pos arrays are required.

Let the two arrays row_terms and starting_pos be shared.
CHAPTER 2 33