CS-240 Data Structures in C Arrays

1
CS-240 Data Structures in CArrays

• Dick Steflik

2
Abstract Data Type

• A collection of pairs ltindex,valuegt 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

3
ADT (cont.)

• Pascal allows discontinous indicies
• A(25, 1020, 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)
• Atom , Adick, Aharry

4
ADT (cont.)

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

5
ADT Operations

• Basic operationscreate(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

6
create

• static storage int a10 //40 bytes
  char word25 //25 bytes
• allocated as part of the program space by the
  compiler.
• a is equivalent to a and is the address of
  a0
• once allocated cannot be deallocated, will always
  take up program space
• can be initialized by compiler using an
  initializer (ex. int A5 (0,0,0,0,0) )

7
create

• Dynamic storage is allocated at run-time using
  malloc, cmalloc or realloc define SIZE 10
  int myarray myarray (int )
  malloc (SIZEsizeof(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
  

8
store

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

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.
  x3 //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

10
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)

11
memory

• remember, a computers 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 a5 a32 to
  calculate the address of a3 addressbase
  address(indexelement size)
  100016 (316416) 100c16base address is
  assigned by compiler for static and by SMS for
  dynamic and kept track of in a system table for
  run time

12
Structures

• Allows us to create and aggregate data type
  typedef struct person
  char name10 int
  age person tom
  - tom takes up 14 bytes of storage 10 for name
  and the next 4 for age

13
Structures

• Structures can be embedded within one another

typedef struct date int
month int date
int year
typedef struct student char
name16 date dateOfBirth

date pearlHarborDay // 12 bytes of
storage student typical // 18 bytes of
storage student class30 // 540 bytes of
storage
14
Unions

• A union is like a structure but the fields dont
  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
name10 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.
15
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
16
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

17
2 dimensional arrays

• int a22 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
1
0
1
0
0
0
1
1
1
18
cont.
int a22
0 1 2 3
0x100000 0x100004 0x100008 0x10000C
0,0 0,1 1,0 1,1
This storage arrangement is known as
Row Major Order
amn)
SMF base addr (dim(n) element size indexm
) (element size indexn )
ex. a11 addr 100000 (2 4 1) (4
1) 100000 8 4 0x10000C
19
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, )

20
Polynomial representation
one dimensional array where index represents
the exponent and the stored value is the
corresponding coefficient
// an array of struct define MAXTERMS
10 typedef struct term
real coeff
int expnt term poly1MAXSIZE term
poly2MAXSIZE term poly3MAXSIZE
OR
2x8 4x2 1
0 1 2 3 4 5 6 7 8 9
2
4
1
21
Identity Matrix

• Only has values on the major diagonal

0 1 2
v
AMFmn if (m n)
return v else return 0
v
0
0
0
0
0
1
0
0
v
2
map it on top of a one dimensional array of three
elements
v
v
v
AMFmn if ( m n ) return Am else
return 0