Vectors, Lists, and Sequences. Vectors: Outline and Reading The Vector ADT (6.1.1) Array-based...
-
Upload
veronica-montgomery -
Category
Documents
-
view
217 -
download
0
description
Transcript of Vectors, Lists, and Sequences. Vectors: Outline and Reading The Vector ADT (6.1.1) Array-based...
Vectors, Lists, and Sequences
Vectors: Outline and Reading
• The Vector ADT (§6.1.1)• Array-based implementation (§6.1.2)
The Vector ADT• The Vector ADT extends
the notion of array by storing a sequence of arbitrary objects
• An element can be accessed, inserted or removed by specifying its rank (number of elements preceding it)
• An exception is thrown if an incorrect rank is specified (e.g., a negative rank)
• Main vector operations:– elemAtRank(int r): returns the
element at rank r without removing it
– replaceAtRank(int r, Object o): replace the element at rank r with o
– insertAtRank(int r, Object o): insert a new element o to have rank r
– removeAtRank(int r): removes the element at rank r
• Additional operations size() and isEmpty()
Applications of Vectors
• Direct applications– Sorted collection of objects (simple database)
• Indirect applications– Auxiliary data structure for algorithms– Component of other data structures
Array-based Vector
• Use an array V of size N• A variable n keeps track of the size of the vector
(number of elements stored)• Operation elemAtRank(r) is implemented in O(1) time
by returning V[r]
V
0 1 2 nr
N-10
Array based Vector: Insertion
• In operation insertAtRank(r,o) we need to make room for the new element by shifting forward the n r elements V[r], …, V[n 1]
• In the worst case (r 0), this takes O(n) time
V
0 1 2 nr
V
0 1 2 nr
V
0 1 2 nor
Deletion• In operation removeAtRank(r) we need to fill the hole
left by the removed element by shifting backward the n r 1 elements V[r 1], …, V[n 1]
• In the worst case (r 0), this takes O(n) time
V
0 1 2 nr
V
0 1 2 nor
V
0 1 2 nr
Performance
• In the array based implementation of a Vector– The space used by the data structure is O(n)– Size(), isEmpty(), elemAtRank(r) and replaceAtRank(r,o)
run in O(1) time– insertAtRank(r,o) and removeAtRank(r) run in O(n) time
• If we use the array in a circular fashion, insertAtRank(0,o) and removeAtRank(0) run in O(1) time
• In an insertAtRank(r,o) operation, when the array is full, instead of throwing an exception, we can replace the array with a larger one
Exercise:
• Implement the Deque ADT using Vector functions– Deque functions:
• first(), last(), insertFirst(e), insertLast(e), removeFirst(), removeLast(), size(), isEmpty()
– Vector functions: • elemAtRank( r), replaceAtRank(r,e), insertAtRank(r,e),
removeAtRank(r ), size(), isEmpty()
Exercise Solution:
• Implement the Deque ADT using Vector functions– Deque functions: first(), last(), insertFirst(e), insertLast(e), removeFirst(), removeLast(), size(), isEmpty()– Vector functions: elemAtRank( r), replaceAtRank(r,e), insertAtRank(r,e), removeAtRank(r ), size(), isEmpty()
– Deque function : Realization using Vector Functions– size() and isEmpty() fcns can simply call Vector fcns
directly– first() => elemAtRank(0)– last() => elemAtRank(size()-1)– insertFirst(e) => insertAtRank(0,e)– insertLast(e) => insertAtRank(size(), e)– removeFirst() => removeAtRank(0)– removeLast() => removeAtRank(size()-1)
STL vector class• Functions in the STL vector class (incomplete)
– Size(), capacity() - return #elts in vector, #elts vector can hold– empty() - boolean– Operator[r] - returns reference to elt at rank r (no index check)– At( r) - returns reference to elt at rank r (index checked)– Front(), back() - return references to first/last elts– push_back(e) - insert e at end of vector– pop_back() - remove last elt– vector(n) - creates a vector of size n
• Similarities & Differences with book’s Vector ADT– STL assignment v[r]=e is equivalent to v.replaceAtRank(r,e)– No direct STL counterparts of insertAtRank( r) & removeAtRank( r)– STL also provides more general fcns for inserting & removing from
arbitrary positions in the vector - these use iterators
Iterators
• An iterator abstracts the process of scanning through a collection of elements
• Methods of the ObjectIterator ADT:– boolean hasNext()– object next()– reset()
• Extends the concept of position by adding a traversal capability
• An iterator is typically associated with an another data structure
• We can augment the Stack, Queue, Vector, and other container ADTs with method:– ObjectIterator elements()
• Two notions of iterator:– snapshot: freezes the contents
of the data structure at a given time
– dynamic: follows changes to the data structure
Iterators• Some functions supported by STL containers
– begin(), end() - return iterators to beginning or end of container
– insert(I,e) - insert e just before the position indicated by iterator I (analogous to our insertBefore(p))
– erase(I) - removes the element at the position indicated by I (analogous to our remove(p))
• The functions can be used to insert/remove elements from arbitrary positions in the STL vector and list
Vector Summary
• Vector Operation Complexity for Different Implementations
Array Fixed-Size or Expandable
ListSingly or Doubly Linked
RemoveAtRank(r),InsertAtRank(r,o)
O(1) Best Case (r=0,n)O(n) Worst CaseO(n) Average Case
?
elemAtRank(r), ReplaceAtRank(r,o)
O(1) ?
Size(), isEmpty() O(1) ?
Lists and Sequences
Outline and Reading
• Singly linked list• Position ADT (§6.2.1)• List ADT (§6.2.2)• Sequence ADT (§6.3.1)• Implementations of the sequence ADT (§6.3.2-3)• Iterators (§6.2.5)
Position ADT
• The Position ADT models the notion of place within a data structure where a single object is stored
• A special null position refers to no object.• Positions provide a unified view of diverse ways of
storing data, such as– a cell of an array– a node of a linked list
• Member functions:– Object& element(): returns the element stored at this
position– bool isNull(): returns true if this is a null position
List ADT (§6.2.2)
• The List ADT models a sequence of positions storing arbitrary objects– establishes a before/after
relation between positions• It allows for insertion and
removal in the “middle” • Query methods:
– isFirst(p), isLast(p)• Generic methods:
– size(), isEmpty()
• Accessor methods:– first(), last()– before(p), after(p)
• Update methods:– replaceElement(p, o),
swapElements(p, q) – insertBefore(p, o),
insertAfter(p, o),– insertFirst(o), insertLast(o)– remove(p)
List ADT
• Query methods:– isFirst(p), isLast(p) :
• return boolean indicating if the given position is the first or last, resp.
• Accessor methods– first(), last():
• return the position of the first or last, resp., element of S• an error occurs if S is empty
– before(p), after(p): • return the position of the element of S preceding or
following, resp, the one at position p• an error occurs if S is empty, or p is the first or last, resp.,
position
List ADT• Update Methods
– replaceElement(p, o)• Replace the element at position p with e
– swapElements(p, q) • Swap the elements stored at positions p & q
– insertBefore(p, o), insertAfter(p, o),• Insert a new element o into S before or after, resp., position p• Output: position of the newly inserted element
– insertFirst(o), insertLast(o)• Insert a new element o into S as the first or last, resp., element• Output: position of the newly inserted element
– remove(p)• Remove the element at position p from S
Exercise:• Describe how to implement the following list
ADT operations using a singly-linked list– list ADT operations: first(), last(), before(p), after(p)– For each operation, explain how it is implemented
and provide the running time• A singly linked list consists of
a sequence of nodes• Each node stores
• element• link to the next node
next
elem node
Leonard Sheldon Howard
head tail
Raj
Exercise:
• Doubly-Linked List Nodes implement Position and store:
• element• link to previous node• link to next node
• Special head/tail nodes
next
elem node
prev
head tail
Leonard Sheldon Howard Raj
• Describe how to implement the following list ADT operations using a doubly-linked list– list ADT operations: first(), last(), before(p), after(p)– For each operation, explain how it is implemented
and provide the running time
Performance
• In the implementation of the List ADT by means of a doubly linked list– The space used by a list with n elements is O(n)– The space used by each position of the list is O(1)– All the operations of the List ADT run in O(1) time– Operation element() of the Position ADT runs in
O(1) time
STL list class• Functions in the STL list class
– size() - return #elements in list, empty() - boolean– front(), back() - return references to first/last elements– push_front(e), push_back(e) - insert e at front/end – pop_front(), pop_back() - remove first/last element– List() - creates an empty list
• Similarities & Differences with book’s List ADT– STL front() & back() correspond to first() & last() except the STL
functions return the element & not its position– STL push() & pop() are equiv to List ADT insert and remove when
applied to the beginning & end of the list– STL also provides functions for inserting & removing from
arbitrary positions in the list - these use iterators
List Summary• List Operation Complexity for different implementations
List Singly-Linked List Doubly- Linked
first(), last(), after(p)insertAfter(p,o), replaceElement(p,o), swapElements(p,q)
O(1) O(1)
before(p), insertBefore(p,o), remove(p)
O(n) O(1)
Size(), isEmpty() O(1) O(1)
Sequence ADT• The Sequence ADT is the union of
the Vector and List ADTs• Elements accessed by
– Rank, or– Position
• Generic methods:– size(), isEmpty()
• Vector-based methods:– elemAtRank(r), replaceAtRank(r,
o), insertAtRank(r, o), removeAtRank(r)
• List-based methods:– first(), last(), before(p),
after(p), replaceElement(p, o), swapElements(p, q), insertBefore(p, o), insertAfter(p, o), insertFirst(o), insertLast(o), remove(p)
• Bridge methods:– atRank(r), rankOf(p)
Applications of Sequences
• The Sequence ADT is a basic, general-purpose, data structure for storing an ordered collection of elements
• Direct applications:– Generic replacement for stack, queue, vector, or list– small database (e.g., address book)
• Indirect applications:– Building block of more complex data structures
Sequence ImplementationsOperation Array Listsize, isEmpty 1 1atRank, rankOf, elemAtRank 1 nfirst, last, before, after 1 1replaceElement, swapElements 1 1replaceAtRank 1 ninsertAtRank, removeAtRank n ninsertFirst, insertLast 1 1insertAfter, insertBefore n 1remove n 1