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.