CS 261 Fall 2009 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 *da, int initCap); void dyArrayFree (struct dyArray *da); void dyArrayAdd (struct dyArray *da, EleType d); EleType dyArrayGet (struct dyArray *da, int index); EleType dyarraySet (struct dyArray *da, int index, EleType newValue); int dyArraySize (struct dyArray *da);

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

dyArrayFree - clean up Void dyArrayFree (struct dyArray * da) { free (da->data); da->capacity = 0; da->size = 0; }

Size int dyArraySize (struct dyArray * da) { return da->size; } Even though one line, still a good idea to hide behind function call abstraction

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; }

How to Double the Capacity Think it through. What are the steps? Need to make a new data buffer array that is twice the size. Need to copy elements from old buffer to new one. Next thought - can we REUSE anything we have done already. We have an init function that creates new buffer. What can we wrap around it?

Outline of operations Double the capacity, can do this by Calling Init the new buffer size Copy elements from old buffer (opps, need to keep reference to old buffer)

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); }

Whats with the underscore? Underscore is just another character for the C compiler Common convention, function names beginning with underscore should not be called directly by user, but are “internal” functions.

Reuse, or not Notice how we reused the init function. Should always look for places where you can reuse code But… Should we have reused add instead of just placing elements into the new buffer Judgement call on very simple operations. (arguments pro and con)

What is O( ) for double What is the O( ) of doubleCapacity? What is therefore the worst case O( ) of add? But do you expect it to be this bad most of the time? Subtle issue, will leave for next class

get and Set, easy operations EleType dyArrayGet (struct dyArray *da, int index) { assert(index >= 0 && index size); return da->data[index]; } Set is similar

Adding to middle, a bit harder Think about the steps Make sure index is legal Make sure you have enough space Slide the remaining elements over Move into the new location Increase size by 1

Do the easy parts first Void dyArrayInsert(struct dyArray * da, int index, EleType newValue) { assert(index >= 0 and index size); if (da->size >= da->capacity) _dyArrayDoubleCapacity(da); /* slide things over - need to do this */ da->data[index] = newValue; da->size++ }

Then do the slide part Well, I need to leave SOMETHING for you to do Hint. It’s a loop.

If we have insert, do we really need add? How are add and insert similar? How are they different? What are some arguments for keeping add, for getting rid of it? In any design, there are tradeoffs. You should think about the alternatives.

Remove - lots of variations There are lots of ways to think about remove. Remove last element. Remove first element. Remove element at given index. Remove a given value. Think reuse - what is the most general function?

Steps in doing removeAt Check that the index is legal Remove by sliding values over Decrement the size

Implement removeAt Void dyArray removeAt(struct dyArray *da, int index) { assert(index >= 0 && index size); /* remove by sliding things over */ /* you get to do this */ da->size--; }

Now we have a nice general purpose tool /* prototypes */ void dyArrayInit (struct dyArray *da, int initCap); void dyArrayFree (struct dyArray *da); void dyArrayAdd (struct dyArray *da, EleType d); EleType dyArrayGet (struct dyArray *da, int index); EleType dyArraySet (struct dyArray *da, int index, EleType newValue); int dyArraySize (struct dyArray *da); Void dyArrayInsert (struct dyArray *da, int index, EleType newValue); Void dyArrayRemoveAt (struct dyArray *da, int index);

Now lets look at making some ADTS How would we make a Bag? (Add, test, remove by value, size) How would we make a Stack (add to top, remove from top, test if empty) We are building these abstractions on top of the implementations we have done already

Stack API Void dyArrayPush (struct dyArray * stk, EleType newValue) { … /* all one or two liners */ } EleType dyArrayTop (struct dyArray * stk) { assert(! dyArrayIsEmpty(stk)); … } Void dyArrayPop (struct dyArray * stk) { … } Int dyArrayIsEmpty (struct dyArray * stk) { … }

Design Decisions This is not the only way to do things - lots of possible design decisions Could have used the dyArray API directly, instead of making the stack wrappers Could have hidden the dynamic array inside a different structure. Think about some of the implications of these choices.

Implementing a Bag What about the Bag API? Bag operations - add, test, remove, size Some of these are already done (which?) Some require more than one line

How to do a test Int dyArrayContains (struct dyArray *da, EleType testValue) { /* loop over all values, checking each */ /* if found, return 1 (true) */ /* if you get to end, return 0 (false) */ } /* you get to write this */

Remove This version of remove takes a value, and removes the FIRST instance of something equal to this What are some of the alternative versions of remove you could think of Can we reduce the problem to the remove we have written already?

Remove void remove (struct dyArray *da, EleType testValue) { int i; for (i = 0; i size; i++) { if (EQ(testValue, da->data[i])) { dyArrayRemoveAt(da, i); return; } }

Your chance At home finish implementation of all the operations we have left unspecific. Next move on to remove to complete the Bag. Then do the stack. Also your implementation will be used in programming assignment 2.