Transcript Dynamic Arrays

CS 261 SUMMER 2011
Dynamic Array Introduction
(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.
Adding an element
 Adding an element to end is sometimes easy.
Just increase the (logical) size, and put new
value at end.
 But what happens when the size reaches the
capacity?
 Must reallocate new data array - but this
detail is hidden from user.
Reallocation and copy
Adding to Middle
 Adding an element to middle can also force
reallocation (if the current size is equal to
capacity)
 But will ALWAYS require elements to moved
up to make space
 Is therefore O(n) worst case
Picture of Adding to Middle
Must use a loop to make space for new value.
Careful! Loop from top down
Removing an Element
 Removing an Element will also require
“sliding over” to delete the value
 Therefore is O(n) worst case
Picture of Remove Element
Remove also requires loop. This time should it
be from top or bottom?
Element Types
 How to make a general purpose container
class?
 We define element type as symbolic
preprocessor constant. Default double.
 Requires recompiling source for new element
types. Not elegant, but workable.
Interface file
#ifndef DyArray_H
#define DyArray_H
# ifndef EleType
# define EleType double
# endif
# ifndef LT
# define LT(a, b) (a < b)
# endif
# ifndef EQ
# define EQ(a, b) (a == b)
# endif
Interface, continued
struct 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)
What about a BAG?
 Already have add. How to do
int dyArrayContains (struct dyArray *d, EleType
e)
 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
Remove At requires extra
work
 RemoveAt requires you to “slide” the
elements down. Think: from the top, or from
the bottom?
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
Your chance
 Worksheet time. Finish implementation of
simple get and set, including reallocation. Next
do the stack. Then move on to remove to
complete the Bag.
 Note that your implementation will be used in
programming assignment 2.
 I’m not going to collect, but you will need this for
the programming assignment.