Vectors, Lists, and Sequences

1
Vectors, Lists, and Sequences
2
Vectors Outline and Reading

• The Vector ADT (6.1.1)
• Array-based implementation (6.1.2)

3
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()

4
Applications of Vectors

• Direct applications
• Sorted collection of objects (simple database)
• Indirect applications
• Auxiliary data structure for algorithms
• Component of other data structures

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

N-1
0
V
0
1
2
n
r
6
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 Vr, , Vn - 1
• In the worst case (r 0), this takes O(n) time

V
0
1
2
n
r
V
0
1
2
n
r
V
o
0
1
2
n
r
7
Deletion

• In operation removeAtRank(r) we need to fill the
  hole left by the removed element by shifting
  backward the n - r - 1 elements Vr 1, , Vn
  - 1
• In the worst case (r 0), this takes O(n) time

8
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

9
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()

10
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() gt elemAtRank(0)
• last() gt elemAtRank(size()-1)
• insertFirst(e) gt insertAtRank(0,e)
• insertLast(e) gt insertAtRank(size(), e)
• removeFirst() gt removeAtRank(0)
• removeLast() gt removeAtRank(size()-1)

11
STL vector class

• Functions in the STL vector class (incomplete)
• Size(), capacity() - return elts in vector,
  elts vector can hold
• empty() - boolean
• Operatorr - 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 books Vector ADT
• STL assignment vre 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

12
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

13
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

14
Vector Summary

• Vector Operation Complexity for Different
  Implementations

Array Fixed-Size or Expandable List Singly or Doubly Linked
RemoveAtRank(r), InsertAtRank(r,o) O(1) Best Case (r0,n) O(n) Worst Case O(n) Average Case ?
elemAtRank(r), ReplaceAtRank(r,o) O(1) ?
Size(), isEmpty() O(1) ?
15
Lists and Sequences
16
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)

17
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

18
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)

19
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

20
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

21
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

22
Exercise

• 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

• Doubly-Linked List Nodes implement Position and
  store
• element
• link to previous node
• link to next node
• Special head/tail nodes

tail
head
23
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

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

25
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)
26
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)

27
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

28
Sequence Implementations
Operation Array List
size, isEmpty 1 1
atRank, rankOf, elemAtRank 1 n
first, last, before, after 1 1
replaceElement, swapElements 1 1
replaceAtRank 1 n
insertAtRank, removeAtRank n n
insertFirst, insertLast 1 1
insertAfter, insertBefore n 1
remove n 1