Date post: | 21-Dec-2015 |
Category: |
Documents |
View: | 221 times |
Download: | 1 times |
CS 261 Winter 2010
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, continuedstruct 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.