Upload
valterra-watson
View
25
Download
3
Embed Size (px)
DESCRIPTION
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. - PowerPoint PPT Presentation
Citation preview
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