1
Standard Containers: Lists
Gordon College
Resource: http://www.cplusplus.com
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 efficient2. 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
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
Lists
Disadvantage to list containers:
* lack direct access to elements by position (vector has direct access)
Must linearly search for a matching element.
5
The list Container
• A type-independent pattern for an array class– capacity can expand– self contained
• Declaration
template <typename T>
class list
{ . . . } ;
6
The list Container
Constructors list<int> first; // default - empty list of
ints
list<int> second (4,100); // four ints with value 100
list<int> third (second.begin(),second.end()); // iterating through second
list<int> fourth (third); // a copy of third
// the iterator constructor can also be used to construct from arrays:
int myints[] = {16,2,77,29}; list<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );
7
The list Container
Destructor ~list ( );
• The object's destructor gets called automatically when the object leaves scope.
8
A quick word about types
for(vector<string>::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
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
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
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 listthen some of the elements are dropped (destructor called)
Default constructorfor type called
100 is used as fill
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
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<int> myvector (2,30);mylist.insert (it,myvector.begin(),myvector.end());
14
list Operations
void swap ( list<T,Allocator>& lst );
list<int> first (3,100); list<int> second (5,200);
first.swap(second);
void reverse ( ); for (int i=1; i<10; i++) mylist.push_back(i);
mylist.reverse();OUTPUT?
15
list Operations
void splice ( iterator position, list<T,Allocator>& x );
// entire x is placed into list
void splice ( iterator position, list<T,Allocator>& x, iterator i );
// only element pointed to by iterator is placed into list
void splice ( iterator position, list<T,Allocator>& x, iterator first, iterator last );
// a range of elements from x is placed into list
16
sort list<string> mylist; list<string>::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
sort list<string> mylist; list<string>::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
sort list<string> mylist; list<string>::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
Predicateremove_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
Predicateunique
bool same_integral_part (double first, double second){
return ( int(first)==int(second) ); }
EXAMPLE
mylist.unique (same_integral_part);
21
Contrast Lists and Vectors
Lists Vectors
• 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
