cs 240 data structures in c arrays
Download
Skip this Video
Download Presentation
CS-240 Data Structures in C Arrays

Loading in 2 Seconds...

play fullscreen
1 / 21

CS-240 Data Structures in C Arrays - PowerPoint PPT Presentation


  • 74 Views
  • Uploaded on

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.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' CS-240 Data Structures in C Arrays' - carsyn


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
abstract data type
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
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 cont1
ADT (cont.)
  • Static arrays – arrays allocated at compile time
  • Dynamic arrays – arrays allocated by the storage management system at program run time
adt operations
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
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); )
create1
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
store
  • done the same way for both static and dynamic arrays by using the assignment operator (=) a[5] = 9;
retrieve
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
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
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) = 100c16base address is assigned by compiler for static and by SMS for dynamic and kept track of in a system table for run time
structures
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
structures1
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
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
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
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
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

1

0

1

0

0

0

1

1

1

slide18
cont.

int a[2][2]

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

a[m][n])

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

ex. a[1][1]

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

= 100000 + 8 + 4 = 0x10000C

sparse arrays
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
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 poly1[MAXSIZE];

term poly2[MAXSIZE];

term poly3[MAXSIZE];

OR

2x8 + 4x2 + 1

0 1 2 3 4 5 6 7 8 9

2

1

4

identity matrix
Identity Matrix
  • Only has values on the major diagonal

0 1 2

v

AMF[m][n]

if (m == n)

return v

else return 0

v

0

0

0

1

0

0

2

0

0

v

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

v

v

AMF[m][n]

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

v

ad