The List ADT Sections 3.2, 3.3, 3.5 Introduction Welcome to COP 4530, Data Structures, Algorithms, and Generic Programming. I hope very much, and sincerely believe, that this course will change you in ways that are deeply satisfying. So far, you have acquired proficiency in programming. This course will start the process of your transformation from a programmer to a computer scientist. One of the important tasks of a computer scientist is to make efficient use of computational resources. This course will teach you about different ways of organizing the data to facilitate such efficient use, and will also discuss efficient techniques to perform some fundamental operations in computer science. A subsequent course on Algorithms, COP 4531, will teach you to use the techniques discussed in this course to solve commonly encountered computer science problems efficiently. Both these courses will also teach you to analyze the efficiency, and prove the correctness, of your program in a mathematically rigorous manner. Material you learn in these two courses is critical to your becoming a good software developer later.

Lists in Everyday Life Shopping list To-do list Dave Letterman’s top 10 list My cat’s revenge list Shopping vector? What if you want to insert an item?

List Wish List Insert an element Remove an element Remove all items Assignment operator Comparison operators Constructors/destructors Generic class Convenient way to iterate through the list

Abstract view of List and Iterator ListElement next next next next null null prev prev prev prev front I1 back Iterator

List Public Interface (contd) Locating places on the list iterator begin(); const iterator begin() const; iterator end(); const iterator end() const; Accessing values on the list Object & front(); Object & back(); (and their const versions)

List Public Interface (contd.) Write functions int push_front(const Object & x); int push_back(const Object & x); int pop_front(); int pop_back(); int insert(iterator & itr, const Object & x); iterator erase( iterator itr); iterator erase( iterator start, iterator end ); void clear();

List Public Interface (contd.) Constructors and destructor List(); List(const List & rhs); ~List();

List Complexity Requirements O(1) Runtime complexity Default Constructor push_front(t), push_back(t), insert(I, t) pop_front(), pop_back(), erase(I) begin(), end(); front(), back(); empty();

List Complexity Requirements (2) O(N) Runtime complexity Copy Constructor Destructor clear() erase(SI,EI)

List Iterator Public Interface Read-only operators int operator== (const iterator & rhs) const; int operator!= (const iterator & rhs) const; Object& operator* ( ) const; // return a reference to // current value Write operators iterator& operator++ ( ); // prefix iterator operator++ ( int ); // postfix iterator& operator-- ( ); // prefix iterator operator-- ( int ); // postfix O(1) requirement for space and time

Using List List<String> KittyVengeance; KittyVengeance.push_front(“toe biting”); “toe biting” KittyVengeance.push_back(“carpet littering”); “toe biting”, “carpet littering” KittyVengeance.push_front(“midnight howling”); “midnight howling”, “toe biting”, “carpet littering” KittyVengeance.push_back(“couch tearing”); “midnight howling”, “toe biting”, “carpet littering”, “couch tearing” List<String>::iterator I; for (I = KittyVengeance.begin(); I != KittyVengence.end(); I++) { // print list with << }

List Insertion Insert “furniture scratching” before “toe biting” // sequential search for (I = KittyVengeance.begin(); I != KittyVengence.end(); I++) { if (“toe biting” == *I) { break; } // insert the new string KittyVengeance.insert(I, “furniture scratching”); “midnight howling”, “furniture scratching”, “toe biting”, “carpet littering”, “couch tearing” // what happens if “toe biting” is not on the list?

Remove all copies of item from List List<String>::iterator I = KittyVengeance.begin(); while( I != KittyVengeance.end()) { if (“couch tearing” == *I) { KittyVengeance.erase(I); } else { I++; }

List and List Iterator Conceptual relationship Iterator I1 begin current end List: A, B, C, D, E, F begin current end Iterator I2

Nodes in a list Node Defined within the List class, with limited scope Pointers to the previous and next element Data Value Defined within the List class, with limited scope data prev next data prev next data prev next No need for contiguous memory allocation

List Implementation A Doubly Linked List With Header and Tail Nodes as Markers An Empty List

Outline of List Class (Part 1)

Outline of List Class (Part 2)

Outline of List Class (Part 3)

Outline of List Class (Part 4)

const_iterator for List Prefix Postfix

const_iterator class for List (contd.)

iterator class for List Why do we override the parent’s ++ implementation?

iterator class for List (contd.)

List Initialization Routines

List Insert Routine

List Erase Routine