1. Iterators, Lists, and Sequences Data Structures and Algorithms CS 244 Brent M. Dingle, Ph.D. Department of Mathematics, Statistics, and Computer Science University of Wisconsin – Stout Based on the book: Data Structures and Algorithms in C++ (Goodrich, Tamassia, Mount) Some content from Data Structures Using C++ (D.S. Malik)

2. Points of Note Check assignment due dates HW08 due April 3 (today) HW09 due April 10

3. Last Time Last class we talked about Linked Lists Dynamic Arrays Book’s Vector ADT The Vector ADT (§6.1.1) Array-based implementation (§6.1.2) Stacks Queues Dequeues

4. Today Review: Iterators Iterators (§6.2.5)  mostly FYI Lists and Sequences as ADTs Position ADT (§6.2.1)  mostly FYI List ADT (§6.2.2) Sequence ADT (§6.3.1) Sorting

5. Iterators Some functions supported by STL containers such as: – 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 linked list operation: insertBefore(p) – erase(I) – removes the element at the position indicated by I – analogous to our linked list operation: remove(p) The functions can be used to insert/remove elements from arbitrary positions in the STL vector and list Review

6. Iterators Example In the previous class there was an exercise that was based on the code: Located at or near something like: Content  Unit2  InClass  Examples  Ex225_DequeWithIters.cpp Code example from this follows next slide

7. Iterator Example myDeque.push_back( 'H' ); myDeque.push_back( 'O' ); myDeque.push_back( 'W' ); myDeque.push_back( 'D' ); myDeque.push_back( 'Y' ); //--------------------------------------------------------------------- // Change them back but this time use iterators // instead of reference pointers. // Note how we dereference the iterators with * when setting them. myDequeType::iterator it_begin = myDeque.begin(); myDequeType::iterator it_end = myDeque.end(); *it_begin = 'H'; // Change the first element from h back to H --it_end; *it_end = 'Y'; // Change the last element from y to back to Y // typedef deque myDequeType;

8. Iterator Example 2 void printContents( myDequeType deque ) { //--------------------------------------------------------------------- // Using iterators, // which point to the beginning and ending of the vector, // loop through the vector and print out its contents myDequeType::iterator it_begin = deque.begin(); myDequeType::iterator it_end = deque.end(); cout << "Contents of myDeque: "; while (it_begin != it_end ) { cout << *it_begin << " " ; ++it_begin } cout << endl; } // typedef deque myDequeType;

9. Group Class Activity Create a program that instantiates a vector of integers using std::vector Then using a loop Based on iterators begin() and end() Pushes the Fibonacci numbers into the vector object 1 1 2 3 5… Starter Code can be found on D2L Circa: Unit2  InClass  Examples  GCA210_VectorIterators.tar.gz Submit the code to the correct D2L dropbox 1 submission per “group” Put all group member names in comments at top of main CPP file Forward and Backward

10. Lists and Sequences

11. FYI Background: Position ADT The Position ADT models the notion of place within a data structure where a single object is stored – often in the sense of relative position such as A is before B, or Z is after Y – also in the sense of first, second, third, … last rather than just at index i A special null position refers to no object. Positions provide a unified view of diverse ways of storing data – 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

12. Book’s 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) This is NOT a linked list description It is a LIST Abstract Data Type

13. List ADT Query methods: – isFirst(p), isLast(p) : return boolean indicating if the given position is the first or last, respectively. 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, respectively, the one at position p an error occurs if S is empty, or p is the first or last, resp., position S is the list

14. 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 S is the list

15. Class Exercises Follow You are about to see 2 exercises Mostly a compare and contrast exercise set Think about run times too This is a group discussion activity Elect someone in your group to capture what is talked about in a MS-Word or text document Randomly selected groups will present their findings at conclusion of each exercise

16. Exercise 1 of 2 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 tail LeonardSheldonHoward  Raj A singly linked list consists of a sequence of nodes Each node stores element link to the next node next elem node Recall head

17. Exercise 2 of 2 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 next elem node prev Doubly-Linked List Nodes implement Position and store: element link to previous node link to next node Special head/tail nodes Recall head tail LeonardSheldon HowardRaj  

18. Solution: Singly Linked List In the implementation of the List ADT by means of a singly 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) The before() operation runs in O(n) time All the other operations of the List ADT run in O(1) time Enhanced Version

19. Solution: Doubly Linked List 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 Enhanced Version

20. Variances of Implementation The details of implementing a list will vary So STL implementation does not always match the book’s described ADT This is common So always check the interface description wherever you may work

21. 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 book’s first() & last() except the STL functions return the element & not its position STL push() & pop() are equiv to the book’s 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

22. List Summary List Operation Complexity for different implementations List Singly-LinkedList 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)O(1) Size(), isEmpty()O(1)

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

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

25. Sequence Implementations OperationArrayList size, isEmpty 11 atRank, rankOf, elemAtRank 1n first, last, before, after 11 replaceElement, swapElements 11 replaceAtRank 1n insertAtRank, removeAtRank nn insertFirst, insertLast 11 insertAfter, insertBefore n1 remove n1 This is important! It summarizes the differences between an Array and a List

26. Outline and Reading Where we are headed Bubble Sort (§6.4) Merge Sort (§11.1) Summary of sorting algorithms

27. The End of This Part Next Bubble Sort and Merge Sort Chapter 6 and 11.1