CS-240 Data Structures in C

Arrays

Dick Steflik

Abstract Data Type

• A collection of pairs <index,value> where index is an ordered set of integers and are values of some data type that is constant for the array.

• not all languages require index to be continuous or contiguous or start at 0 or 1.

• In C arrays are zero based and are contiguous from 0 to size-1 and can contain any simple or aggregate data type

ADT (cont.)

• Pascal allows discontinous indicies– A(2:5, 10:20, 26) other index values are

undefined and take up no memory• Perl allows indicies that are not integers

but are literal values (called an associative array)– A[tom] , A[dick], A[harry]

ADT (cont.)

• Static arrays – arrays allocated at compile time

• Dynamic arrays – arrays allocated by the storage management system at program run time

ADT Operations

• Basic operations:create(A) – allocates storageretrieve(A,i) – return v at position i in A store(A,I,v) – store v at position i in Adestroy(A) – deallocate storage associated with A

create

• static storage : int a[10]; //40 bytes char word[25]; //25 bytes– allocated as part of the program space by the

compiler.– &a is equivalent to a and is the address of a[0]

– once allocated cannot be deallocated, will always take up program space

• can be initialized by compiler using an initializer (ex. int A[5] = (0,0,0,0,0); )

create• Dynamic : storage is allocated at run-time using

malloc, cmalloc or realloc #define SIZE 10 int * myarray; myarray = (int *) malloc (SIZE*sizeof(int)); makes an array of 10 integers names myarray

• cmalloc works same way but initializes array to 0initialization to anything else requires a loop

• realloc will resize a previously allocated array to bigger or smaller

• since this happens at run time, time is expended

store

• done the same way for both static and dynamic arrays by using the assignment operator (=)

a[5] = 9;

retrieve

• retrieving a value from some position in an array is done the same way for both static and dynamic arrays using the array position implicitly. x[3] ; //the value of the 4th element of x

• can be used this way in any assignment, arithmetic/logical operation or as an argument in a function call

destroy• destruction of a statically allocated array

happened when the program is done• destruction of dynamically allocated arrays is

done using the free(arrayname) function, this returns the storage to the storage management system for subsequent allocation for something else.

• forgetting to deallocate unneeded storage is called a “memory leak” and can cause a program terminate abnormally (crash)

memory• remember, a computer’s memory is really an

array of bytes (indicies 0 to size-1)• every time an array access (retrieve or store) is

done the machine must make a calculation to see where in memory the desired location is: ex int a[5]; a[3]=2; to calculate the address of a[3] address=base address+(index*element size) = 100016 + (316*416) = 100c16

base address is assigned by compiler for static and by SMS for dynamic and kept

track of in a system table for run time

Structures• Allows us to create and aggregate data

type: typedef struct person { char name[10]; int age; } person tom; - tom takes up 14 bytes of storage; 10 for name and the next 4 for age

Structures

• Structures can be embedded within one another:

typedef struct date

{ int month;

int date;

int year;

};

typedef struct student

{ char name[16];

date dateOfBirth;

};

date pearlHarborDay; // 12 bytes of storage

student typical; // 18 bytes of storage

student class[30]; // 540 bytes of storage

Unions• A union is like a structure but the fields don’t

always have to have the same definition

typedef struct sextype

{ enum tag (female, male) sex;

union {

int children;

char beard;

} u;

};

typedef struct human

{ char name[10];

short age;

float salary;

date dob;

sextype sexinfo;

};

The compiler will always reserve the maximum number bytes for the union; i.e.

even though sextype for wormen is 4 bytes and only one byte for men the compiler will always reserve 4.

Self-Referential Structures

• Structure that refers to an item of the same type.

• used for dynamic data structures like lists and trees.

typedef struct node

{ int key;

node * next;

}

Array Mapping Functions

• Used by the compiler to help calculate the effective address of an array element in memory

• Takes into account: base address the dimension the element size

2 dimensional arrays

• int a[2][2] can be visualized as a 2x2 square matrix but is really an array of two elements where each element is an array of two ints

0

0 1

1

0

1

0 1

0 1

cont.

0x100000

0x100004

0x100008

0x10000C

0,0

0,1

1,0

1,1

int a[2][2]

This storage arrangement is known as:

Row Major Order

0 1 2 3

SMF = base addr + (dim(n) * element size * indexm ) + (element size * indexn )

a[m][n])

ex. a[1][1]

addr = 100000 + (2 * 4 * 1) + (4 * 1)

= 100000 + 8 + 4 = 0x10000C

Sparse Arrays

• arrays where many or most of the elements will have the value zero (or possibly the same value)

• examples: high order polynomials, bit mapped graphics, linear algebra ( diagional matricies(identity matrix, tridiagonal, banded), triangular matrices, )

Polynomial representation

// an array of struct

#define MAXTERMS 10

typedef struct term {

real coeff;

int expnt;}

term poly1[MAXSIZE];

term poly2[MAXSIZE];

term poly3[MAXSIZE];

one dimensional array where:

index represents the exponent

and the stored value is the

corresponding coefficient

0 1 2 3 4 5 6 7 8 9

2x8 + 4x2 + 1

241

OR

Identity Matrix• Only has values on the major diagonal

v0 0

v 0 0

0 0 v

0 1 2

0

1

2

AMF[m][n]

if (m == n)

return v

else return 0

map it on top of a one dimensional array of three elements

v v v AMF[m][n]

if ( m == n ) return A[m] else return 0