1. Vectors, Lists and Sequences
Chapter 6:
Vectors, Lists and Sequences
Nancy Amato
Parasol Lab, Dept. CSE, Texas A&M University
Acknowledgement: These slides are adapted from slides provided with Data Structures and Algorithms in C++, Goodrich, Tamassia and Mount (Wiley ) 1 1

2. Vectors: Outline and Reading
The Vector ADT (§6.1.1)
Array-based implementation (§6.1.2)
2/24/2019 6:40 AM
Vectors

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()
2/24/2019 6:40 AM
Vectors

4. Applications of Vectors
Direct applications
Sorted collection of objects (elementary database)
Indirect applications
Auxiliary data structure for algorithms
Component of other data structures
2/24/2019 6:40 AM
Vectors

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 V[r]
N-1 V 1 2 r n
2/24/2019 6:40 AM
Vectors

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 V[r], …, V[n - 1]
In the worst case (r = 0), this takes O(n) time V 1 2 r n V 1 2 r n V o 1 2 r n
2/24/2019 6:40 AM
Vectors

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 V[r + 1], …, V[n - 1]
In the worst case (r = 0), this takes O(n) time V 1 2 n o r V 1 2 n r V 1 2 n r
2/24/2019 6:40 AM
Vectors

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
2/24/2019 6:40 AM
Vectors

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()
2/24/2019 6:40 AM
Vectors

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() => elemAtRank(0)
last() => elemAtRank(size()-1)
insertFirst(e) => insertAtRank(0,e)
insertLast(e) => insertAtRank(size(), e)
removeFirst() => removeAtRank(0)
removeLast() => removeAtRank(size()-1)
2/24/2019 6:40 AM
Vectors

11. 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 counerparts of insertAtRank( r) & removeAtRank( r)
STL also provides more generatl fcns for inserting & removing from arbitrary positions in the vector - these use iterators
2/24/2019 6:40 AM
Vectors

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
May be implemented with an array or singly linked list
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
2/24/2019 6:40 AM
Vectors

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 elt at the position indicated by I (analogous to our remove(p))
The functions can be used to insert/remove elts from arbitrary positions in the STL vector and list
2/24/2019 6:40 AM
Vectors

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 (r=0,n)
O(n) Worst Case
O(n) Average Case ?
elemAtRank(r), ReplaceAtRank(r,o)
O(1)
Size(), isEmpty()
2/24/2019 6:40 AM
Vectors

15. Lists and Sequences Vectors 2/24/2019 6:40 AM Vectors

16. Outline and Reading Singly linked list Position ADT (§6.2.1)
List ADT (§6.2.2)
Doubly linked list (§ 6.2.3)
Sequence ADT (§6.3.1)
Implementations of the sequence ADT (§ )
Iterators (§6.2.5)
2/24/2019 6:40 AM
Vectors

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
2/24/2019 6:40 AM
Vectors

18. List ADT (§5.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: Accessor 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
2/24/2019 6:40 AM
Vectors

20. List ADT Update Methods Vectors 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
remove(p)
Remove the element at position p from S
2/24/2019 6:40 AM
Vectors

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
next
elem
node
A singly linked list concrete data structure consists of a sequence of nodes
Each node stores
element
link to the next node A B C D 
2/24/2019 6:40 AM
Vectors

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
prev
next
elem
node
Doubly-Linked List Nodes implement Position and store:
element
link to previous node
link to next node
Special trailer and header nodes
trailer
header
elements
2/24/2019 6:40 AM
Vectors

23. Insertion
We visualize operation insertAfter(p, X) which returns position q p A B C p q A B C X p q A B X C
2/24/2019 6:40 AM
Vectors

24. Deletion We visualize remove(p), where p = last() A B C D p A B C p D
2/24/2019 6:40 AM
Vectors

25. 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
2/24/2019 6:40 AM
Vectors

26. STL list class Functions in the STL list class
Size() - return #elts in list, empty() - boolean
Front(), back() - return references to first/last elts
Push_front(e), push_back(e) - insert e at front/end
Pop_front(), pop_back() - remove first/last elt
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 fcns for inserting & removing from arbitrary positions in the list - these use iterators
2/24/2019 6:40 AM
Vectors

27. 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)
before(p), insertBefore(p,o), remove(p)
O(n) WC & AC
O(1) BC
Size(), isEmpty()
2/24/2019 6:40 AM
Vectors

28. Sequence ADT List-based methods: Bridge methods:
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)
2/24/2019 6:40 AM
Vectors

29. 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
2/24/2019 6:40 AM
Vectors

30. Array-based Implementation
elements
We use a circular array storing positions
A position object stores:
Element
Rank
Indices f and l keep track of first and last positions 1 2 3
positions S f l
2/24/2019 6:40 AM
Vectors

31. Sequence Implementations
Operation
Array
List
size, isEmpty 1
atRank, rankOf, elemAtRank n
first, last, before, after
replaceElement, swapElements
replaceAtRank
insertAtRank, removeAtRank
insertFirst, insertLast
insertAfter, insertBefore
remove
2/24/2019 6:40 AM
Vectors