CS 261 Winter 2011

Dynamic Array Worksheet Review

(aka Vector, ArrayList)

Arrays, Pro and Con

• Simple Arrays have nice feature that they are randomly accessible - can quickly get to any element

• Dark side - size must be fixed when created.

• Often you don’t know much much space you need until you are done

Dynamic Array (Vector, ArrayList)

• Dynamic Array (Java Vector, ArrayList, same thing, different API) get around this by encapsulating a partially filled array.

• Hide memory management details behind a simple API

• Is still randomly accessible, but now it grows as necessary

Partially Filled Array

Size vs Capacity

• The size is the “logical” size - The number of elements. What the programmer thinks. Managed by an internal data value.

• The capacity is the size of the physical array. Number of elements it can hold.

Interfacestruct dyArray { EleType * data; int size; int capacity;};

/* prototypes */void dyArrayInit (struct dyArray *v, int initCap);void dyArrayFree (struct dyArray *v);void dyArrayAdd (struct dyArray *v, EleType d);EleType dyArrayGet (struct dyArray *v, int index);EleType dyarraySet (struct dyArray *v, int index, EleType

newValue);int dyArraySize (struct dyArray *v);

dyArrayInit - initialization

void dyArrayInit (struct dyArray * v, int initCap){ assert (initCap >= 0); v->capacity = initCap; v->size = 0; v->data = (double *) malloc(v->capacity * sizeof(EleType)); assert (v->data != 0);}

dyArrayFree - clean up

Void dyArrayFree (struct dyArray * v)

{

free (v->data);

v->capacity = 0;

v->size = 0;

}

Size

int dyArraySize (struct dyArray * da)

{

return da->size;

}

Add a new Element

void dyArrayAdd (struct dyArray * da, EleType newValue)

{ if (da->size >= da->capacity)

_dyArrayDoubleCapacity(da);

da->data[da->size] = newValue;

da->size += 1;

}

Double the Capacity

void _dyArrayDoubleCapacity (struct dyArray * da) { EleType * oldbuffer = da->data; int oldsize = da->size; int i; dyArrayInit (da, 2 * da->capacity); for (i = 0; i < oldsize; i++) da->data[i] = oldbuffer[i]; da->size = oldsize; free(oldbuffer);}

Lets build something

• How about building a Stack (worksheet 16)? What do you need to do to:

void dyArrayPush(struct dyArray *d, EleType n)EleType dyArrayTop(struct dyArray *d)void dyArrayPop (struct dyArray *d)int dyArrayIsEmpty (struct dyArray *d)

Push

void dyArrayPush(struct dyArray *d, EleType n)

{

/* why reinvent the wheel? */

dyArrayAdd(d, n);

}

Top

EleType dyArrayTop(struct dyArray *d)

{

/* make sure there are enough places */

assert(dyArraySize(d) > 0);

return dyArrayGet(d, 0);

}

Pop

void dyArrayPop(struct dyArray *d)

{

/* make sure there are enough places */

assert(dyArraySize(d) > 0);

d->size--; /* just reduce size by one*/

}

isEmpty

int dyArrayIsEmpty (struct dyArray * d)

{

return dyArraySize(d) == 0;

}

What about a BAG?

• Already have add and size. How to do

int dyArrayContains (struct dyArray *d, EleType e)

• Just like previous version

• What about remove?

What about remove?

• Make more useful tool by writing two routines

Void dyArrayRemove (struct dyArray *d, EleType e)

Void dyArrayRemoveAt (struct dyArray *d, int index)

Think about breaking tasks down into useful pieces

dyArrayRemove

void dyArrayRemove (struct dyArray *d, EleType e)

{

int i;

for (i = 0; i < d->size; i++)

if (EQ(e, d->data[i])) {

dyArrayRemoveAt(d, i);

return;

}

}

Remove At requires extra work

• RemoveAt requires you to “slide” the elements down. Think: from the top, or from the bottom?

dyArrayRemoveAt

void dyArrayRemoveAt(struct dyArray *d, int index)

{

int i;

assert(index >= 0 && index < d->size);

d->size--;

for (i = index; i < d->size; i++)

dyArrayData[i] = dyArrayData[i+1];

}

What about addAt ?

• We don’t need dyArrayAddAt for the bag (order doesn’t matter), but it is a nice complement to removeAt

• And we will us it later when we talk about the advantages of keeping a collection in order