标准模板库(STL)学习探究之List容器

                                                                       C++ Lists(链表)

    Lists将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢.
函数列表如下:
assign() 给list赋值
back() 返回最后一个元素
begin() 返回指向第一个元素的迭代器
clear() 删除所有元素
empty() 如果list是空的则返回true
end() 返回末尾的迭代器
erase() 删除一个元素
front() 返回第一个元素
get_allocator() 返回list的配置器
insert() 插入一个元素到list中
max_size() 返回list能容纳的最大元素数量
merge() 合并两个list
pop_back() 删除最后一个元素
pop_front() 删除第一个元素
push_back() 在list的末尾添加一个元素
push_front() 在list的头部添加一个元素
rbegin() 返回指向第一个元素的逆向迭代器
remove() 从list删除元素
remove_if() 按指定条件删除元素
rend() 指向list末尾的逆向迭代器
resize() 改变list的大小
reverse() 把list的元素倒转
size() 返回list中的元素个数
sort() 给list排序
splice() 合并两个list
swap() 交换两个list
unique() 删除list中重复的元素

/////////////////////////////////////////////////////////////////////////////////////
                              函数详细说明
构造函数constructors
explicit list(const A& al = A());
explicit list(size_type n, const T& v = T(), const A& al = A());
list(const list& x);
list(const_iterator first, const_iterator last, const A& al = A());
以上四个构造函数在实际中有以下几种情况:
(1)list() 声明一个空列表；
(2)list(al) 声明一个空列表，但它还存储一个分配器对象al;
(3)list(n) 声明一个有n个元素的列表，每个元素都是由其默认构造函数T()构造出来的;
(4)list(n,val) 声明一个由n个元素的列表，每个元素都是由其复制构造函数T(val)得来的;
(5)list(n,val,al) 声明一个和上面一样的列表，但还存储分配器对象al;
(6)list(first,last) 声明一个列表，其元素的初始值来源于由区间所指定的序列中的元素;
(7)list(first,last,al) 声明一个和上面一样的列表，但它还存储分配器对象al;
赋值(assign)
语法:
  void assign( input_iterator start, input_iterator end );
  void assign( size_type num, const TYPE &val );
assign()函数以迭代器start和end指示的范围为list赋值或者为list赋值num个以val为值的元素。assign为了将被控序列替换成由(first,last)所指定的序列,且不能是原序列的一部分。
back
语法:
  reference back();
  const_reference back() const;
back()函数返回一个引用，指向list的最后一个元素。
begin
语法:
  iterator begin();
  const_iterator begin() const;
begin()函数返回一个迭代器，指向list的第一个元素。例如，

    // 创建一个元素类型是字符的链表
    list<char> charList;
    for( int i=0; i < 10; i++ )
      charList.push_front( i + 65 );

    // 显示这个链表
    list<char>::iterator theIterator;
    for( theIterator = charList.begin(); theIterator != charList.end(); theIterator++ )
      cout << *theIterator;
clear
语法:
  void clear();
clear()函数删除list的所有元素。
empty
语法:
  bool empty();
empty()函数返回真(true)如果链表为空，否则返回假。例如：

    list<int> the_list;
    for( int i = 0; i < 10; i++ )
      the_list.push_back( i ); 
    while( !the_list.empty() ) {
      cout << the_list.front() << endl;
      the_list.pop_front();
    }
end
语法:
  iterator end();
end()函数返回一个迭代器，指向链表的末尾。
erase
语法:
  iterator erase( iterator pos );
  iterator erase( iterator start, iterator end );
erase()函数删除以pos指示位置的元素, 或者删除start和end之间的元素。 返回值是一个迭代器，指向最后一个被删除元素的下一个元素。
front
语法:
  reference front();
  const_reference front() const;
front()函数返回一个引用，指向链表的第一个元素。

    list<int> the_list;
    for( int i = 0; i < 10; i++ )
      the_list.push_back( i ); 
    while( !the_list.empty() ) {
      cout << the_list.front() << endl;
      the_list.pop_front();
    }
get_allocator
语法:
  allocator_type get_allocator();
get_allocator()函数返回链表的配置器。
insert
语法:
  iterator insert( iterator pos, const TYPE &val );
  void insert( iterator pos, size_type num, const TYPE &val );
  void insert( iterator pos, input_iterator start, input_iterator end );

insert()插入元素val到位置pos，或者插入num个元素val到pos之前，或者插入start到end之间的元素到pos的位置。返回值是一个迭代器，指向被插入的元素。
示例:
#include<iostream>
#include<list>
using namespace std;
void main()
{
    list<int>lst;
 for(int i=0;i<4;i++)
 {
     lst.push_back(i);
 }
    list<int>::iterator p=lst.insert(lst.begin(),5);
    cout<<*p<<endl;
}
输出结果为:5
max_size
语法:
  size_type max_size();
max_size()函数返回链表能够储存的元素数目。
merge
语法:
  void merge( list &lst );
  void merge( list &lst, Comp compfunction );
merge()函数把自己和lst链表连接在一起，产生一个整齐排列的组合链表。如果指定compfunction，则将指定函数作为比较的依据。
示例:
  list<int>lst,lst1;
  lst.push_back(3);
  lst.push_back(2);
  lst.push_back(6);
  lst.push_back(9);
  lst1.push_back(1);
  lst1.push_back(8);
  lst1.push_back(2);
  lst1.push_back(7);
//lst.sort();
//lst1.sort();
  lst.merge(lst1);
  list<int>::iterator p=lst.begin();
  for(int j=0;j<lst.size();j++)//未排序,结果的排序就没有任何保证了。
  {
     cout<<*p<<" "; 
     p++;
  }
  list<int>::iterator q=lst1.begin();
  for(int k=0;k<lst1.size();k++)//合并后lst1被清空
  {
     cout<<*q<<" ";
     q++;
  }
  cout<<endl;
输出结果:
        1 3 2 6 8 2 7 9
pop_back
语法:
  void pop_back();
pop_back()函数删除链表的最后一个元素。
pop_front
语法:
  void pop_front();
pop_front()函数删除链表的第一个元素。
push_back
语法:
  void push_back( const TYPE &val );
push_back()将val连接到链表的最后。例如：

    list<int> the_list;
    for( int i = 0; i < 10; i++ )
      the_list.push_back( i );
push_front
Syntax:
  void push_front( const TYPE &val );
push_front()函数将val连接到链表的头部。
rbegin
语法:
  reverse_iterator rbegin();
rbegin()函数返回一个逆向迭代器，指向链表的末尾。
rend(),
remove
语法:
  void remove( const TYPE &val );
remove()函数删除链表中所有值为val的元素。例如

    // 创建一个链表，元素是字母表的前10个元素
    list<char> charList;
    for( int i=0; i < 10; i++ )
      charList.push_front( i + 65 );

    // 删除所有'E'的实例
    charList.remove( 'E' );
  remove_if
语法:
  void remove_if( UnPred pr );
remove_if()以一元谓词pr为判断元素的依据，遍历整个链表。如果pr返回true则删除该元素。
示例：
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
void main()
{
    const int VECTOR_SIZE = 8 ;
    // Define a template class vector of integers
    typedef vector<int > IntVector ;
    //Define an iterator for template class vector of integer
    typedef IntVector::iterator IntVectorIt ;
    IntVector Numbers(VECTOR_SIZE) ;   //vector containing numbers

    IntVectorIt start, end, it, last;

    start = Numbers.begin() ;   // location of first
                                // element of Numbers

    end = Numbers.end() ;       // one past the location
                                // last element of Numbers

    //Initialize vector Numbers
    Numbers[0] = 10 ;
    Numbers[1] = 20 ;
    Numbers[2] = 10 ;
    Numbers[3] = 15 ;
    Numbers[4] = 12 ;
    Numbers[5] = 7 ;
    Numbers[6] = 9 ;
    Numbers[7] = 10 ;

    cout << "Before calling remove_if" << endl ;

    // print content of Numbers
    cout << "Numbers { " ;
    for(it = start; it != end; it++)
        cout << *it << " " ;
    cout << " }/n" << endl ;

    // remove all elements from Numbers that <= 10
     last = remove_if(start, end, bind2nd(less_equal<int>(), 10) ) ;

    cout << "After calling remove_if" << endl ;

    // print content of Numbers
    cout << "Numbers { " ;
    for(it = start; it != end; it++)//在输出结果中我们将看到remove_if并没有删除<=10的
        cout << *it << " " ;        //数，而是将它们放到了序列的后面
    cout << " }/n" << endl ;

    //print number of elements removed from Numbers
    cout << "Total number of elements removed from Numbers = "
        << end - last << endl ;

    //print only the valid elements of Number
    Numbers.erase(last,end);   //彻底删除<=10的数
    cout << "Valid elements of Numbers { " ;
    for(it = start; it != last; it++)
        cout << *it << " " ;
    cout << " }/n" <<Numbers.size()<< endl ;

}
输出结果：
Before calling remove_if
Numbers { 10 20 10 15 12 7 9 10  }

After calling remove_if
Numbers { 20 15 12 15 12 7 9 10  }

Total number of elements removed from Numbers = 5
Valid elements of Numbers { 20 15 12  }

rend
语法:
  reverse_iterator rend();
rend()函数迭代器指向链表的头部。
resize
语法:
  void resize( size_type num, TYPE val );
resize()函数把list的大小改变到num，超出的元素将被删除。被加入的多余的元素都被赋值为val
reverse
语法:
  void reverse();
reverse()函数把list所有元素倒转。如果与sort()联用可以将list按降序排列。
size
语法:
  size_type size();
size()函数返回list中元素的数量。
排序(sort)
语法:
  void sort();
  void sort( Comp compfunction );
sort()函数为链表排序，默认是升序(降序greater<int>())。如果指定compfunction的话，就采用指定函数来判定两个元素的大小。

c++中有一个通用算法sort,功能与list中的sort相似，遗憾的是通用算法sort并不能用于list进行排序。下面对其进行详细介绍。
声明：
template<class RanIt>
    void sort(RanIt first, RanIt last);
template<class RanIt, class Pred>
    void sort(RanIt first, RanIt last, Pred pr);
示例：
// functional_greater_equal.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
void main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter1;

   int i;
   v1.push_back( 6262 );
   v1.push_back( 6262 );
   for ( i = 0 ; i < 5 ; i++ )
   {
      v1.push_back( rand( ) );
   }

   cout << "Original vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   // To sort in ascending order,
   // use default binary predicate less<int>( )
   sort( v1.begin( ), v1.end( ) );
   cout << "Sorted vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;
   // To sort in descending order,
   // specify binary predicate greater_equal<int>( )
   sort( v1.begin( ), v1.end( ), greater_equal<int>( ) );//greater、less、less_equal
   cout << "Resorted vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;
}
输出结果：
Original vector v1 = ( 6262 6262 41 18467 6334 26500 19169 )
Sorted vector v1 = ( 41 6262 6262 6334 18467 19169 26500 )
Resorted vector v1 = ( 26500 19169 18467 6334 6262 6262 41 )
自定义排序算法：
示例：
#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
using namespace std;
class myclass {
        public:
        myclass(int a, int b):first(a), second(b){}
        int first;
        int second;
        bool operator < (const myclass &m)const {
                return first < m.first;
        }
};

bool less_second(const myclass & m1, const myclass & m2) {
        return m1.second < m2.second;
}

int main() {
       
        vector< myclass > vect;
        for(int i = 0 ; i < 10 ; i ++){
                myclass my(10-i, i*3);
                vect.push_back(my);
        }
        for(int j = 0 ; j < vect.size(); j ++)
             cout<<"("<<vect[j].first<<","<<vect[j].second<<")/n";
        sort(vect.begin(), vect.end());
        cout<<"after sorted by first:"<<endl;
        for(int k = 0 ; k < vect.size(); k ++)
              cout<<"("<<vect[k].first<<","<<vect[k].second<<")/n";
        cout<<"after sorted by second:"<<endl;
        sort(vect.begin(), vect.end(), less_second);
        for(int n = 0 ; n < vect.size(); n ++)
            cout<<"("<<vect[n].first<<","<<vect[n].second<<")/n";
       
        return 0 ;
}
输出结果：
(10,0)
(9,3)
(8,6)
(7,9)
(6,12)
(5,15)
(4,18)
(3,21)
(2,24)
(1,27)
after sorted by first:
(1,27)
(2,24)
(3,21)
(4,18)
(5,15)
(6,12)
(7,9)
(8,6)
(9,3)
(10,0)
after sorted by second:
(10,0)
(9,3)
(8,6)
(7,9)
(6,12)
(5,15)
(4,18)
(3,21)
(2,24)
(1,27)

splice
语法:
  void splice( iterator pos, list &lst );
  void splice( iterator pos, list &lst, iterator del );
  void splice( iterator pos, list &lst, iterator start, iterator end );
splice()函数把lst连接到pos的位置。如果指定其他参数，则插入lst中del所指元素到现链表的pos上，或者用start和end指定范围。splice 把另一个list中的元素结合到一个list中。它从源list中删除元素。
示例：
   list<int>lst,lst1;
   lst.push_back(3);
   lst.push_back(2);
   lst.push_back(6);
   lst.push_back(9);
   lst1.push_back(1);
   lst1.push_back(8);
   lst1.push_back(2);
   lst1.push_back(7);
   list<int>::iterator p=lst1.begin();
   p++;
   list<int>::iterator r=lst.begin();
   lst.splice(r,lst1,p);//lst1中的p指向的位置的元素被删除
   r=lst.begin();
   for(int i=0;i<lst.size();i++)
   {
      cout<<*r<<" ";
      r++;
   }
   cout<<endl;
   list<int>::iterator q=lst1.begin();
   for(int j=0;j<lst1.size();j++)
   {
      cout<<*q<<" ";
      q++;
   }
   cout<<endl;
输出结果为：
          8 3 2 6 9
          1 2 7
swap
语法:
  void swap( list &lst );
swap()函数交换lst和现链表中的元素。
unique
语法:
  void unique();
  void unique( BinPred pr );
unique()函数删除链表中所有重复的元素。如果指定pr，则使用pr来判定是否删除。