Docstoc

CS 261 Spring 2005

Document Sample
CS 261 Spring 2005 Powered By Docstoc
					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, 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.

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:3
posted:6/29/2012
language:English
pages:25