1 / 25

CS 261 Winter 2010

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.

gavin-strong
Download Presentation

CS 261 Winter 2010

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS 261 Winter 2010 Dynamic Array Introduction (aka Vector, ArrayList)

  2. 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

  3. 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

  4. Partially Filled Array

  5. 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.

  6. 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.

  7. Reallocation and copy

  8. 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

  9. Picture of Adding to Middle Must use a loop to make space for new value. Careful! Loop from top down

  10. Removing an Element • Removing an Element will also require “sliding over” to delete the value • Therefore is O(n) worst case

  11. Picture of Remove Element Remove also requires loop. This time should it be from top or bottom?

  12. 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.

  13. 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

  14. 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);

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

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

  17. Size int dyArraySize (struct dyArray * da) { return da->size; }

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

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

  20. 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)

  21. What about a BAG? • Already have add. How to do int dyArrayContains (struct dyArray *d, EleType e) • What about remove?

  22. 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

  23. Remove At requires extra work • RemoveAt requires you to “slide” the elements down. Think: from the top, or from the bottom?

  24. 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

  25. 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.

More Related