1. 1 Standard Containers: Lists Gordon College Resource: http://www.cplusplus.com

2. 2 Lists Another sequential container - the elements have a specific position within the container Internal representation - next lecture Problems with Vector (dynamic arrays): 1.Insert/Deletion from middle of container - not efficient 2.Insert/Deletion from end of container - not efficient if this means expanding or deflating the size of the array (typically not viewed as much of a problem) Solution - the List

3. 3 Lists Advantages to list containers: * Efficient insertion and removal of elements anywhere in the container (constant time). * Efficient moving elements and block of elements within the container or even between different containers (constant time). * Iterating over the elements in forward or reverse order (linear time). * Like Vector - can expand and deflate as needed perform generally better in inserting, extracting and moving elements in any position within the container

4. 4 Lists Disadvantage to list containers: * lack direct access to elements by position (vector has direct access) Must linearly search for a matching element.

5. 5 The list Container A type-independent pattern for an array class –capacity can expand –self contained Declaration template class list {... } ;

6. 6 The list Container Constructors list first; // default - empty list of ints list second (4,100); // four ints with value 100 list third (second.begin(),second.end()); // iterating through second list fourth (third); // a copy of third // the iterator constructor can also be used to construct from arrays: int myints[] = {16,2,77,29}; list fifth (myints, myints + sizeof(myints) / sizeof(int) );

7. 7 The list Container Destructor ~list ( ); The object's destructor gets called automatically when the object leaves scope.

8. 8 A quick word about types for(vector ::size_type i=0;i<strV.size();i++) cout << strV[i] << " "; cout << endl; Typically, we use int or unsigned types to deal with the index into a vector - however the “correct” way is to use a constant size_type associated with the class. Why? This makes our code work for all machine possibilities. Same case for all other containers.

9. 9 list Operations Information about a vector's contents –size_type size() const; L.size(); –bool empty ( ) const; –size_type max_size () const; Basic access and add –reference back ( ); –reference front ( ); –void push_back ( const T& x ); –void push_front ( const T& x );

10. 10 list Operations Remove - iterator erase ( iterator position ); - iterator erase ( iterator first, iterator last ); it1 = mylist.erase (it1); it1 = mylist.erase (it1,it2); Return: iterator pointing to the new location of the element that followed the last element erased -void clear ( ); All the elements are dropped: destructors are called - leaving container with size of 0. Remove by position

11. 11 list Operations Remove - void pop_back ( ); - void pop_front ( ); Removes the elements from back (front) and reduces the size by 1. Remove by position - void resize ( size_type sz, T c = T() ); mylist.resize(5); mylist.resize(8,100); mylist.resize(12); If the sz is smaller than list then some of the elements are dropped (destructor called) Default constructor for type called 100 is used as fill

12. 12 list Operations Remove - void remove ( const T& value ); Removes from the list all the elements with a specific value. This calls the destructor of these objects and reduces the list size by the amount of elements removed. Remove by value - void unique ( ); Removes all duplicate values - leaving only the first value

13. 13 list Operations Add - iterator insert ( iterator position, const T& x ); - void insert ( iterator position, size_type n, const T& x ); - void insert ( iterator position, InputIterator first, InputIterator last ); mylist.insert (it,10); mylist.insert (it,2,20); vector myvector (2,30); mylist.insert (it,myvector.begin(),myvector.end());

14. 14 list Operations void swap ( list & lst ); list first (3,100); list second (5,200); first.swap(second); void reverse ( ); for (int i=1; i<10; i++) mylist.push_back(i); mylist.reverse(); OUTPUT?

15. 15 list Operations void splice ( iterator position, list & x ); // entire x is placed into list void splice ( iterator position, list & x, iterator i ); // only element pointed to by iterator is placed into list void splice ( iterator position, list & x, iterator first, iterator last ); // a range of elements from x is placed into list

16. 16 sort list mylist; list ::iterator it; mylist.push_back ("one"); mylist.push_back ("two"); mylist.push_back ("Three"); mylist.sort(); cout << "mylist contains:"; for (it=mylist.begin(); it!=mylist.end(); ++it) cout << " " << *it; cout << endl; mylist.sort(compare_nocase); cout << "mylist contains:"; for (it=mylist.begin(); it!=mylist.end(); ++it) cout << " " << *it; cout << endl;

17. 17 sort list mylist; list ::iterator it; mylist.push_back ("one"); mylist.push_back ("two"); mylist.push_back ("Three"); mylist.sort(); cout << "mylist contains:"; for (it=mylist.begin(); it!=mylist.end(); ++it) cout << " " << *it; cout << endl; mylist.sort(compare_nocase); cout << "mylist contains:"; for (it=mylist.begin(); it!=mylist.end(); ++it) cout << " " << *it; cout << endl; bool compare_nocase (string first, string second) { unsigned int i=0; while ( (i<first.length()) && (i<second.length()) ) { if (tolower(first[i])<tolower(second[i])) return true; else if (tolower(first[i])>tolower(second[i])) return false; ++i; } if (first.length()<second.length()) return true; else return false; }

18. 18 sort list mylist; list ::iterator it; mylist.push_back ("one"); mylist.push_back ("two"); mylist.push_back ("Three"); mylist.sort(); cout << "mylist contains:"; for (it=mylist.begin(); it!=mylist.end(); ++it) cout << " " << *it; cout << endl; mylist.sort(compare_nocase); cout << "mylist contains:"; for (it=mylist.begin(); it!=mylist.end(); ++it) cout << " " << *it; cout << endl;

19. 19 Predicate remove_if A Predicate is a Unary Function whose result represents the truth or falsehood of some condition. // a predicate implemented as a function: bool single_digit (const int& value) { return (value<10); } // a predicate implemented as a class: class is_odd { public: bool operator() (const int& value) {return (value%2)==1; } }; EXAMPLE mylist.remove_if (single_digit); mylist.remove_if (is_odd());

20. 20 Predicate unique bool same_integral_part (double first, double second) { return ( int(first)==int(second) ); } EXAMPLE mylist.unique (same_integral_part);

21. 21 Contrast Lists and Vectors ListsVectors Constant time O(1) to add or remove elements from inside the list Element access is linear Constant time to move elements or blocks of elements within or between lists Linear time O(n) to add or remove elements from inside the list Element access is constant Linear time to move elements or blocks of elements within or between lists