Chapter 6 Sequences vectors and lists COL 106

Chapter 6: Sequences : vectors and lists COL 106 Shweta Agrawal

Highlights from last class • Parenthesis matching using stack • Growable array based stack • Incremental strategy • Doubling strategy • • Queue using circular array or singly linked list C++ interface for stack and queues Dequeue (“deck”) using doubly linked list Stacks or queues using dequeue Vectors 11/1/2020 1: 50 PM 2

Containers • Some time ago we saw the notion of a class in C++ • A class is like an ADT – it contains data members and also contains function members that specify how the data should be accessed • Classes provided by STL are organized in various groups • Particularly important is the container group • A container is a data structure that stores a collection of objects • Classified into associative containers and sequence 3 containers (called just sequences) 11/1/2020 1: 50 PM

Sequences • Suppose we have a collection S of n elements stored in a linear order, so that we can refer to the elements in S as first, second, third, and so on. • Such a collection is generically referred to as a sequence. • We can uniquely refer to each element e in S using an integer in the range [0, n− 1] that is equal to the number of elements of S that precede e in S. • The index of an element e in S is the number of elements that are before e in S. The rank of an element is defined to be one more than its index 11/1/2020 1: 50 PM Vectors 4

Examples of sequences • Array : implements a compile-time nonresizeable array. • Vector : implements an array with fast random access and an ability to automatically resize when appending elements. • Deque : implements a double ended queue with comparatively fast random access. • List : implements a doubly linked list. • Forward_list : implements a singly linked list Vectors 11/1/2020 1: 50 PM 5

Vectors • The Vector ADT extends the • Main vector operations: – elem. At. Rank(int r): returns the notion of array element at rank r without removing it • An element can be – replace. At. Rank(int r, Object o): accessed, inserted or replace the element at rank r with removed by specifying its o index/rank – insert. At. Rank(int r, Object o): insert a new element o to have rank r • An exception is thrown if an – remove. At. Rank(int r): removes the incorrect rank is specified element at rank r (e. g. , a negative rank) • Additional operations size() and is. Empty() Vectors 11/1/2020 1: 50 PM 6

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 elem. At. Rank(r) is implemented in O(1) time by returning V[r] N-1 0 V 0 1 2 n r Vectors 11/1/2020 1: 50 PM 7

Array based Vector: Insertion • In operation insert. At. Rank(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 r n 0 1 2 o r V V Vectors n 11/1/2020 1: 50 PM 8

Deletion • In operation remove. At. Rank(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 o r n 0 1 2 r V V Vectors n 11/1/2020 1: 50 PM 9

Performance • In the array based implementation of a Vector – The space used by the data structure is O(n) – Size(), is. Empty(), elem. At. Rank(r) and replace. At. Rank(r, o) run in O(1) time – insert. At. Rank(r, o) and remove. At. Rank(r) run in O(n) time • If we use the array in a circular fashion, insert. At. Rank(0, o) and remove. At. Rank(0) run in O(1) time (how? ) • In an insert. At. Rank(r, o) operation, when the array is full, instead of throwing an exception, we can replace the array with a larger one Vectors 11/1/2020 1: 50 PM 10

Exercise: • Implement the Deque ADT using Vector functions – Deque functions: • first(), last(), insert. First(e), insert. Last(e), remove. First(), remove. Last(), size(), is. Empty() – Vector functions: • elem. At. Rank( r), replace. At. Rank(r, e), insert. At. Rank(r, e), remove. At. Rank(r ), size(), is. Empty() Vectors 11/1/2020 1: 50 PM 11

Exercise Solution: • Implement the Deque ADT using Vector functions – – Deque functions: first(), last(), insert. First(e), insert. Last(e), remove. First(), remove. Last(), size(), is. Empty() Vector functions: elem. At. Rank( r), replace. At. Rank(r, e), insert. At. Rank(r, e), remove. At. Rank(r ), size(), is. Empty() – Deque function : Realization using Vector Functions – size() and is. Empty() fcns can simply call Vector fcns directly – first() => elem. At. Rank(0) – last() => elem. At. Rank(size()-1) – insert. First(e) => insert. At. Rank(0, e) – insert. Last(e) => insert. At. Rank(size(), e) – remove. First() => remove. At. Rank(0) – remove. Last() => remove. At. Rank(size()-1) Vectors 11/1/2020 1: 50 PM 12

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. replace. At. Rank(r, e) – No direct STL counterparts of insert. At. Rank( r) & remove. At. Rank( r) – STL also provides more general functions for inserting & removing from arbitrary positions in the vector - these use iterators Vectors 11/1/2020 1: 50 PM 13

Stacks versus Vectors • If you can only push_back and pop_back, then this is LIFO access. • What is the difference from a stack? • Interface is different. For example, can access elements in the middle in a vector vs 14

Vectors vs Arrays • Apart from usual index operator (“[ ]”), elements can be accessed by member function at which performs range checking. • Unlike C++ arrays, STL vectors can be dynamically resized • When an STL vector of class objects is destroyed, it automatically invokes the destructor for each of its elements. With C++ arrays, it is the obligation of the programmer to do this explicitly. • Several functions that operate on entire vectors, not just on individual elements. E. g. : copy all or part of one vector to another, compare the contents of two vectors, insert and erase multiple elements. 15

Accessing vector elements • Vectors support dynamic size change • Contiguous blocks of memory unlikely to be found, unlike array • Arrays use index to traverse elements • How can one traverse elements of a vector if they are stored non-contiguously? • How to keep track of the position of an element though its index may keep changing? Using Position and Iterator ADTs 16

Position ADT • Say vector contains an element “Delhi” that we want to keep track of • The index of the element may keep changing depending on insert/delete operations • A position s, may be associated with the element Delhi (say at time of insertion) • s lets us access Delhi via s. element() even if the index of Delhi changes in the container, unless we explicitly remove s • A position ADT is associated with a s particular container. Delhi 17

Iterator ADT • • • Abstracts the process of scanning through a container Encapsulates the notions of “place” and “next” Extends the position ADT by adding a traversal capability Generic and specialized iterators Object. Iterator has. Next() next. Object() object() Sequences 18

Example using Iterator 19

C++ STL support for 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 – Erase(I) - removes the elt at the position indicated by I • The functions can be used to insert/remove elts from arbitrary positions in the STL vector and list Vectors 11/1/2020 1: 50 PM 20

Vector Summary • Vector Operation Complexity for Different List Implementations Array Fixed-Size or Expandable Singly or Doubly Linked Remove. At. Rank(r), Insert. At. Rank(r, o) O(1) Best Case (r=0, n) O(n) Worst Case O(n) Average Case ? elem. At. Rank(r), Replace. At. Rank(r, o) O(1) ? Size(), is. Empty() O(1) ? Vectors 11/1/2020 1: 50 PM 21

Lists Vectors 11/1/2020 1: 50 PM 22

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 (§ 6. 3. 2 -3) Iterators (§ 6. 2. 5) Vectors 11/1/2020 1: 50 PM 23

Position ADT • As in vectors, the Position ADT models the notion of place within a data structure where a single object is stored • 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(p): returns the element stored at this position – bool is. Null(): returns true if this is a null position Vectors 11/1/2020 1: 50 PM 24

List ADT that captures linked lists • 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: – is. First(p), is. Last(p) • Generic methods: – size(), is. Empty() • Accessor methods: – first(), last() – before(p), after(p) • Update methods: – replace. Element(p, o), swap. Elements(p, q) – insert. Before(p, o), insert. After(p, o), – insert. First(o), insert. Last(o) – remove(p) 25

List ADT • Query methods: – is. First(p), is. Last(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 Vectors 11/1/2020 1: 50 PM 26

List ADT • Update Methods – replace. Element(p, e) • Replace the element at position p with e – swap. Elements(p, q) • Swap the elements stored at positions p & q – insert. Before(p, o), insert. After(p, o), • Insert a new element o into S before or after, resp. , position p • Output: position of the newly inserted element – insert. First(o), insert. Last(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 Vectors 11/1/2020 1: 50 PM 27

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 • A singly linked list concrete data structure consists of a sequence of nodes • Each node stores elem • element • link to the next node A B Vectors C D 11/1/2020 1: 50 PM 28

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 • Doubly-Linked List Nodes implement Position and store: • element • link to previous node • link to next node elem trailer header • Special trailer and header nodes Vectors elements 11/1/2020 1: 50 PM 29

Insertion • We visualize operation insert. After(p, X) which returns position q p A B p C p A q B C X p A q B Vectors X q C 11/1/2020 1: 50 PM 30

Deletion • We visualize remove(p), where p = last() p A B C D p D A B Vectors C 11/1/2020 1: 50 PM 31

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 Vectors 11/1/2020 1: 50 PM 32

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 Vectors 11/1/2020 1: 50 PM 33

List Summary • List Operation Complexity for different implementations List Singly-Linked List Doubly- Linked first(), last(), after(p) insert. After(p, o), replace. Element(p, o), swap. Elements(p, q) O(1) before(p), insert. Before(p, o), remove(p) O(n) WC & AC O(1) BC O(1) Size(), is. Empty() O(1) Vectors 11/1/2020 1: 50 PM 34

Sequence ADT Generalizes vectors and lists • The Sequence ADT is the union • List-based methods: of the Vector and List ADTs – first(), last(), before(p), • Elements accessed by after(p), replace. Element(p, o), – Rank, or swap. Elements(p, q), – Position insert. Before(p, o), • Generic methods: insert. After(p, o), – size(), is. Empty() insert. First(o), • Vector-based methods: insert. Last(o), – elem. At. Rank(r), remove(p) replace. At. Rank(r, o), • Bridge methods: insert. At. Rank(r, o), remove. At. Rank(r) – at. Rank(r), rank. Of(p) Vectors 11/1/2020 1: 50 PM 35

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 0 1 2 3 positions S f Vectors l 11/1/2020 1: 50 PM 36

Sequence Implementations Operation size, is. Empty at. Rank, rank. Of, elem. At. Rank first, last, before, after replace. Element, swap. Elements replace. At. Rank insert. At. Rank, remove. At. Rank insert. First, insert. Last insert. After, insert. Before remove Vectors Array 1 1 1 List 1 n 1 1 1 n n 1 11/1/2020 1: 50 PM 37