1. Chapter 2 Arrays and Structures Instructors: C. Y. Tang and J. S. Roger Jang All the material are integrated from the textbook "Fundamentals of Data Structures in C" and some supplement from the slides of Prof. Hsin-Hsi Chen (NTU).

2. Outline The array as an abstract data type Structures and unions The polynomial abstract data type The sparse matrix abstract data type Representation of multidimensional arrays The string abstract data type

3. Outline The array as an abstract data type Structures and unions The polynomial abstract data type The sparse matrix abstract data type Representation of multidimensional arrays The string abstract data type

4. 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.

5. Abstract Data Type Array Structure Array is objects : a set of pairs where for each value of index there is a value from the set item. functions: Array Create (j, list) : an array of j dimensions, where list is a j-tuple whose ith element is the size of the ith dimension. Item Retrieve (A, i) : If (i ε index) return the item indexed by i in array A, else return error. Array Store (A, i, x) : If (i ε index) insert and return the new array, else return error. end Array

6. Implementation in C int list[5], *plist[5]; VariableMemory Address list[0]base address = α list[1]α + sizeof(int) list[2]α + 2*sizeof(int) list[3]α + 3*sizeof(int) list[4]α + 4*sizeof(int) The names of the five array elements Assume the memory address α = 1414, list[0] = 6, list[2] = 8, plist[3] = list = 1414 printf( “ %d ”, list); // 1414, the variable “ list ” is the pointer to an int printf( “ %d ”, &list[0]) // 1414, return the address using “ & ” printf( “ %d ”, list[0]); // 6, the value stored in the address “ &list[0] ” printf( “ %d ”, (list + 2)); // 1414 + 2*sizeof(int), “ (list +2) ” is a pointer printf( “ %d ”, *(list + 2)); // 8 printf( “ %d ”, plist[3]); // 1414, the value of a pointer is an address printf( “ %d ”, *plist[3]); // 6

7. Example: One-dimensional array accessed by address call print1(&one[0], 5) 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”); } int one[] = {0, 1, 2, 3, 4}; Goal: print out address and value

8. Example: Array program #define MAX_SIZE 100 float sum(float [], int); float input[MAX_SIZE], answer; int i; void main (void) { for (i = 0; i < MAX_SIZE; i++) input[i] = i; answer = sum(input, MAX_SIZE); printf("The sum is: %f\n", answer); } float sum(float list[], int n) { int i; float tempsum = 0; for (i = 0; i < n; i++) tempsum += list[i]; return tempsum; } Result : The sum is: 4950.000000

9. Outline The array as an abstract data type Structures and unions The polynomial abstract data type The sparse matrix abstract data type Representation of multidimensional arrays The string abstract data type

10. Structures (Records) struct { char name[10]; // a name that is a character array int age; // an integer value representing the age of the person float salary; // a float value representing the salary of the individual } person; strcpy(person.name, “ james ” ); person.age=10; person.salary=35000; An alternate way of grouping data that permits the data to vary in type. Example:

11. 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;

12. Example: Embed a structure within a structure typedef struct { int month; int day; int year; } date; typedef struct human_being { char name[10]; int age; float salary; date dob; }; person1.dob.month = 2; person1.dob.day = 11; person1.dob.year = 1944;

13. 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; boolean beard; } u; }; typedef struct human_being { char name[10]; int age; float salary; date dob; sex_type sex_info; } human_being person1, person2; person1.sex_info.sex = male; person1.sex_info.u.beard = FALSE; person2.sex_info.sex = female; person2.sex_info.u.children = 4;

14. 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; item1.data=‘a’; item2.data=‘b’; item3.data=‘c’; item1.link=item2.link=item3.link=NULL; abc Construct a list with three nodes item1.link=&item2; item2.link=&item3; malloc: obtain a node

15. Outline The array as an abstract data type Structures and unions The polynomial abstract data type The sparse matrix abstract data type Representation of multidimensional arrays The string abstract data type

16. Implementation on other data types Arrays are not only data structures in their own right, we can also use them to implement other abstract data types. Some examples of the ordered (linear) list : - Days of the week: (Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday). - Values in a deck of cards: (Ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, King) - Floors of a building: (basement, lobby, mezzanine, first, second) Operations on lists : - Finding the length, n, of the list. - Reading the items from left to right (or right to left). - Retrieving the ith element from a list, 0 ≦ i < n. - Replacing the ith item of a list, 0 ≦ i < n. - Inserting a new item in the ith position of a list, 0 ≦ i < n. - Deleting an item from the ith position of a list, 0 ≦ i < n.

17. Abstract data type Polynomial Structure Polynomial is objects: ; a set of ordered pairs of where a i in Coefficients and e i in Exponents, e i 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 inserted 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 x expon Polynomial Add(poly1, poly2) ::= return the polynomial poly1 +poly2 Polynomial Mult(poly1, poly2) ::= return the polynomial poly1 poly2 End Polynomial degree : the largest exponent of a polynomial

18. Two types of Implementation for the polynomial ADT Type I : #define MAX_DEGREE 1001 typedef struct { int degree; float coef[MAX_DEGREE]; } polynomial; polynomial a; a.degree = n a. coef[i] = a n-i, 0 ≦ i ≦ n. Type II : MAX_TERMS 1001 /* size of terms array */ typedef struct { float coef; int expon; } polynomial; polynomial terms[MAX_TERMS]; int avail = 0; /* recording the available space*/ starta finish a startbfinishbavail coef2111031 exp100004320 0123456 advantage: easy implementation disadvantage: waste space when sparse storage requirements: start, finish, 2*(finish-start+1) nonparse:twice as much as Type I when all the items are nonzero P A =2x 1000 +1 P B =x 4 +10x 3 +3x 2 +1 Poly A coef1…002 exp (i n d ex) 0…998999 100 0 Poly B coef103101…0 exp (i n d ex) 01234… 100 0

19. Polynomials adding of Type I /* 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)); b = Remove(b, Lead_Exp(b)); } 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 // case -1: Lead_exp(a) < Lead_exp(b) // case 0: Lead_exp(a) = Lead_exp(b) // case 1: Lead_exp(a) < Lead_exp(b)

20. Polynomials adding of Type II 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[avail], terms[startb].coef, terms[startb].expon); startb++; avail++; break; case 0: /* equal exponents */ coefficient = terms[starta].coef + terms[startb].coef; if (coefficient) attach (terms[avail], coefficient, terms[starta].expon); starta++; startb++; avail++; break; case 1: /* a expon > b expon */ attach(terms[avail], terms[starta].coef, terms[starta].expon); starta++; avail++; } /* add in remaining terms of A(x) */ for( ; starta <= finisha; starta++) { attach(terms[avail], terms[starta].coef, terms[starta].expon); avail++; } /* add in remaining terms of B(x) */ for( ; startb <= finishb; startb++) { attach(terms[avail], terms[startb].coef, terms[startb].expon); avail++; } *finishd =avail -1; }

21. Outline The array as an abstract data type Structures and unions The polynomial abstract data type The sparse matrix abstract data type Representation of multidimensional arrays The string abstract data type

22. The sparse matrix abstract data type Matrix a Nonzero rate : 15/15 Dense ! col_0col_1col_2 row_0-2734 row_1682-2 row_2109-6411 row_31289 row_4482747 col_ 0 col_ 1 col_ 2 col_ 3 col_ 4 col_ 5 row_01500220-15 row_10113000 row_2000-600 row_3000000 row_49100000 row_50028000 Matrix b Nonzero rate : 8/36 Sparse !

23. Abstract data type Sparse_Matrix Structure Sparse_Matrix is objects: a set of triples,, 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. 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.

24. Sparse_Matrix Create and transpose #define MAX_TERMS 101 /* maximum number of terms +1 */ typedef struct { int col; int row; int value; } term; term a[MAX_TERMS] for each row i (or column j) take element and store it in element of the transpose. rowcol valu e a[0]668 [1]0015 [2]0322 [3]05-15 [4]1111 [5]123 [6]23-6 [7]4091 [8]5228 rowcol valu e b[0]668 [1]0015 [2]0491 [3]1111 [4]213 [5]2528 [6]3022 [7]32-6 [8]50-15 Sparse matrix and its transpose stored as triples #(rows) #(columns) #(nonzero entries) any element within a matrix using the triple Difficulty: what position to put ?

25. Transpose of a sparse matrix in O(columns*elements) 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 */ b[currentb].row = a[j].col; b[currentb].col = a[j].row; b[currentb].value = a[j].value; currentb++ } } } Scan the array “columns” times. The array has “elements” elements. ==> O(columns*elements)

26. Analysis and improvement Discussion: compared with 2-D array representation O(columns*elements) vs. O(columns*rows) #(elements)  columns * rows, when the matrix is not sparse. O(columns*elements)  O(columns*columns*rows) Problem: Scan the array “ columns ” times. Improvement: Determine the number of elements in each column of the original matrix. => Determine the starting positions of each row in the transpose matrix.

27. Transpose of a sparse matrix in O(columns + elements) 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++) row_terms[i] = 0; for (i = 1; i <= num_terms; i++) row_terms[a[i].col]++ starting_pos[0] = 1; for (i =1; i < num_cols; i++) starting_pos[i]=starting_pos[i-1] +row_terms [i-1]; for (i=1; i <= num_terms, i++) { j = starting_pos[a[i].col]++; b[j].row = a[i].col; b[j].col = a[i].row; b[j].value = a[i].value; } } } O(num_cols) O(num_terms) O(num_cols-1) O(num_terms) O(columns + elements)

28. Sparse matrix multiplication void mmult (term a[ ], term b[ ], term d[ ] ) /* multiply two sparse matrices */ { int i, j, column, totalb = b[].value, totald = 0; int rows_a = a[0].row, cols_a = a[0].col, totala = a[0].value; int cols_b = b[0].col, int row_begin = 1, row = a[1].row, sum =0; int new_b[MAX_TERMS][3]; if (cols_a != b[0].row){ fprintf (stderr, “ Incompatible matrices\n ” ); exit (1); } fast_transpose(b, new_b); /* set boundary condition */ a[totala+1].row = rows_a; new_b[totalb+1].row = cols_b; new_b[totalb+1].col = 0; for (i = 1; i <= totala; ) { column = new_b[1].row; for (j = 1; j <= totalb+1;) { /* mutiply row of a by column of b */ if (a[i].row != row) { storesum(d, &totald, row, column, &sum); i = row_begin; for (; new_b[j].row == column; j++) ; column =new_b[j].row } else if (new_b[j].row != column){ storesum(d, &totald, row, column, &sum); i = row_begin; column = new_b[j].row; } else switch (COMPARE (a[i].col, new_b[j].col)) { case -1: /* go to next term in a */ i++; break; case 0: /* add terms, go to next term in a and b */ sum += (a[i++].value * new_b[j++].value); break; case 1: /* advance to next term in b*/ j++ } } /* end of for j <= totalb+1 */ for (; a[i].row == row; i++) ; row_begin = i; row = a[i].row; } /* end of for i <=totala */ d[0].row = rows_a; d[0].col = cols_b; d[0].value = totald; }

29. storesum function void storesum(term d[ ], int *totald, int row, int column, int *sum) { /* if *sum != 0, then it along with its row and column position is stored as the *totald+1 entry in d */ if (*sum) if (*totald < MAX_TERMS) { d[++*totald].row = row; d[*totald].col = column; d[*totald].value = *sum; } else { fprintf(stderr, ” Numbers of terms in product exceed %d\n ”, MAX_TERMS); exit(1); } }

30. Analyzing the algorithm cols_b * termsrow 1 + totalb + cols_b * termsrow 2 + totalb + … + cols_b * termsrow rows_a + totalb = cols_b * (termsrow 1 + termsrow 2 + … + termsrow rows_a ) + rows_a * totalb = cols_b * totala + row_a * totalb O(cols_b * totala + rows_a * totalb)

31. Compared with classic multiplication algorithm 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) mmult vs. classic O(cols_b * totala + rows_a * totalb) vs. O(rows_a * cols_a * cols_b)

32. Matrix-chain multiplication n matrices A 1, A 2, …, A n with size p 0  p 1, p 1  p 2, p 2  p 3, …, p n-1  p n To determine the multiplication order such that # of scalar multiplications is minimized. To compute A i  A i+1, we need p i-1 p i p i+1 scalar multiplications. e.g. n=4, A 1 : 3  5, A 2 : 5  4, A 3 : 4  2, A 4 : 2  5 ((A 1  A 2 )  A 3 )  A 4, # of scalar multiplications: 3 * 5 * 4 + 3 * 4 * 2 + 3 * 2 * 5 = 114 (A 1  (A 2  A 3 ))  A 4, # of scalar multiplications: 3 * 5 * 2 + 5 * 4 * 2 + 3 * 2 * 5 = 100 (A 1  A 2 )  (A 3  A 4 ), # of scalar multiplications: 3 * 5 * 4 + 3 * 4 * 5 + 4 * 2 * 5 = 160

33. Let m(i, j) denote the minimum cost for computing A i  A i+1  …  A j Computation sequence : Time complexity : O(n 3 ) Matrix-chain multiplication (cont.)

34. Outline The array as an abstract data type Structures and unions The polynomial abstract data type The sparse matrix abstract data type Representation of multidimensional arrays The string abstract data type

35. Representation of multidimensional arrays The internal representation of multidimensional arrays requires more complex addressing formulas. a[upper 0 ] [upper 1 ] … [upper n-1 ] => #(elements of a) = There are two ways to represent multidimensional arrays: row major order and column major order. (row major order stores multidimensional arrays by rows) Ex. A[upper 0 ][upper 1 ] : upper 0 rows (row 0, row 1, …,row upper0-1 ), each row containing upper 1 elements Assume that α is the address of A[0][0]  the address of A[i][0] : α+ i *upper 1  A[i][j] : α+ i *upper 1 +j row major : 1234 5678 9101112 column major : 14710 25811 36912

36. Representation of Multidimensional Arrays (cont.) n dimensional array addressing formula for A[i 0 ][i 1 ] … [i n-1 ] : Assume that the address of A[0][0] … [0] is α.  the address of A[i 0 ][0][0] … [0] : α + i 0 *upper 1 *upper 2 * … *upper n-1  A[i 0 ][i 1 ][0] … [0] : α + i 0 *upper 1 *upper 2 * … *upper n-1 + i 1 *upper 2 *upper 3 * … *upper n-1  A[i 0 ][i 1 ][i 2 ] … [i n-1 ] : α + i 0 *upper 1 *upper 2 * … *upper n-1 + i 1 *upper 2 *upper 3 * … *upper n-1 + i 2 *upper 3 *upper 4 * … *upper n-1 ﹕ + i n-2 *upper n-1 + i n-1

37. Outline The array as an abstract data type Structures and unions The polynomial abstract data type The sparse matrix abstract data type Representation of multidimensional arrays The string abstract data type

38. Structure String is objects : a finite set of zero or more characters. functions : for all s, t  String, i, j, m  non-negative integers String Null(m) ::= return a string whose maximum length is m characters, but initially set to NULL. We write NULL as “”. Integer Compare(s, t) ::= if s equals t return 0 else if s precedes t return -1 else return +1 Boolean IsNull(s) ::= if (Compare(s, NULL)) return FALSE else return TRUE Integer Length(s) ::= if (Compare(s, NULL)) return the number of characters in s else return 0 String Concat(s, t) ::= if (Compare(t, NULL)) return a string whose elements are those of s followed by those of t else return s String Subset(s, i, j) ::= if ((j>0) && (i+j-1)<Length(s)) return the string containing the characters of s at position i, i+1, …, i+j-1. else return NULL.

39. C string functions

40. String insertion function void strnins(char *s, char *t, int i) { /* insert string t into string s at position i */ char string[MAX_SIZE], *temp = string; if (i strlen(s)) { fprintf(stderr, ” Position is out of bounds \n ” ); exist(1); } if (!strlen(s)) strcpy(s, t); else if (strlen(t)) { strncpy(temp, s, i); strcat(temp, t); strcat(temp, (s+i)); strcpy(s, temp); } s→amobile \0\0 t→uto\0 temp→\0 initially temp→a\0 (a) after strncpy (temp, s, i) temp→auto\0 (b) after strcat (temp, t) temp→automobile\0 (c) after strcat (temp, (s+i)) Example: Never be used in practice, since it ’ s wasteful in use of time and space !

41. Pattern matching algorithm (checking end indices first) int nfind(char *string, char *pat) { /* match the lat character of pattern first, and then match from the beginning */ int i, j, start = 0; int lasts = strlen(string) – 1; int lastp = strlen(pat) – 1; int endmatch = lastp; for (i = 0; endmatch <= lasts; endmatch++, start++){ if (string[endmatch] == pat[lastp]) for (j = 0, i = start; j < lastp && string[i] == pat[j]; i++, j++) ; if (j == lastp) return start; /* successful */ } return -1; }

42. Simulation of nfind aab ↑↑ jlastp (a) pattern ababbaabaa ↑↑↑ startendmatchlasts (b) no match ababbaabaa ↑↑↑ startendmatchlasts (c) no match ababbaabaa ↑↑↑ startendmatchlasts (d) no match ababbaabaa ↑↑↑ startendmatchlasts (e) no match ababbaabaa ↑↑↑ startendmatchlasts (f) no match ababbaabaa ↑↑↑ star t endmatchlasts (g) match

43. Failure function used in KMP algorithm Definition: If P = p 0 p 1 … p n-1 is a pattern, then its failure function, f, is defined as: Example: pat = ‘ abcabcacab ’ A fast way to compute the failure function: Largest i < j such that p 0 p 1 … p i = p j-i p j-i-1 … p j if such an i ≧ 0 exists if j = 0 Where m is the least integer k for which if there is no k satisfying the above j0123456789 patabcabcacab f -1 -1 -1 0123 -1 01

44. KMP algorithm (1/5) Case 1: the first symbol of P dose not appear again in P Case 2: the first symbol of P appear again in P

45. KMP algorithm (2/5) Case 3: not only the first symbol of P appears in P, prefixes of P appear in P twice

46. KMP algorithm (3/5) The KMP Algorithm The Prefix function

47. KMP algorithm (4/5)

48. KMP algorithm (5/5) #include #define max_string_size 100 #define max_pattern_size 100 int pmatch(); void fail(); int failure[max_pattern_size]; char string[max_string_size]; char pat[max_pattern_size]; int pmatch (char *string, char *pat) { /* Knuth, Morris, Pratt string matching algorithm */ 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); } void fail (char *pat) { /* compute the pattern ’ s failure function */ int n = strlen(pat); failure[0] = -1; for (j = 1; j < n; j++) { i = failure[j-1]; while ((pat[j] != pat[i+1]) && (I >= 0)) i = failure[i]; if (pat[j] == pat[i+1]) failure[j] = i + 1; else failure[j] = -1; } O(strlen(stirng)) O(strlen(pattern)) O(strlen(stirng)+strlen(pat))

49. An Example for KMP algorithm (1/6) P 1 ≠T 1, mismatch Since j=1, i = i + 1

50. An Example for KMP algorithm (2/6) T 5 ≠P 4, mismatch P f(4-1)+1 =P 0+1 =P 1

51. An Example for KMP algorithm (3/6) P 1 ≠T 5, mismatch Since j=1, i = i + 1

52. An Example for KMP algorithm (4/6) Match exactly P f(12)+1 =P 4+1 =P 5

53. An Example for KMP algorithm (5/6) T 19 ≠P 6, mismatch P f(6-1)+1 =P 0+1 =P 1

54. An Example for KMP algorithm (6/6)...