Data Structures and Algorithms Arrays
Amjad Ali
Introducation
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
cont..
Pascal allows discontinuous indices
A(2:5, 10:20, 26) other index values are undefined and take up no memory
Perl allows indices that are not integers but are literal values (called an associative array)
A[tom] , A[dick], A[harry]
Array Types
Static arrays arrays allocated at compile time Dynamic arrays arrays allocated by the storage management system at program run time
Array Operations
Basic operations: create(A) allocates storage retrieve(A,i) return v at position i in A store(A,I,v) store v at position i in A destroy(A) deallocate storage associated with A
Create (Static Array)
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 Array)
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 0 initialization 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
Dynamic arrays are created using the new operator
Example: To create an array of 10 elements of type double:
typedef double* DoublePtr; DoublePtr d; d = new double[10];
Create (Dynamic Array) C++
d can now be used as if it were an ordinary array!
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
destruction of a statically allocated array happened when the program is done destruction of dynamically allocated arrays is done using the free(arrayname)
destroy
delete [ ] d;
The brackets tell C++ a dynamic array is being deleted so it must check the size to know how many indexed variables to remove
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)
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
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 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
cont.
int a[2][2]
0123
0x100000
0x100004 0x100008 0x10000C
0,0
0,1 1,0 1,1 a[m][n] ) This storage arrangement is known as: Row Major Order
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
