STL之list

        list是双向循环链表，双链表既可以向前又可以向后链接它的元素。在STL中，list和vector一样，是两个常被使用的容器。list不像vector那样，list的内存分配时是非连续的，因此，list不支持对元素的任意存取，只能通过迭代器来访问list中的元素。list将元素按顺序储存在链表中. 与向量(vector)相比, 它允许快速的插入和删除，但是随机访问却比较慢。list在头和尾都可以插入元素。list中提供的成员函数与vector类似，不过list提供对表首元素的操作push_front、pop_front，这是vector不具备的。和vector另一点不同的是，list的迭代器不会存在失效的情况，它不像vector会保留备份空间，在超过容量额度时重新全部分配内存，导致迭代器失效；list没有备份空间的概念，出入一个元素就申请一个元素的空间，所以它的迭代器不会失效。

int data[6]={3,5,7,9,2,4};  
list<int> lidata(data, data+6);  
lidata.push_back(6); 

        list初始化时，申请的空间大小为6，存放下了data中的6个元素，当向lidata插入第7个元素“6”时，list申请新的节点单元，插入到list链表中，数据存放结构如图所示：

        list每次增加一个元素，不存在重新申请内存的情况，它的成本是恒定的。而vector每当增加关键元素的时候，都需要重新申请新的更大的内存空间，会调用元素的自身的复制构造函数，存在构造成本。在销毁旧内存的时候，会调用析构函数，存在析构成本。所以在存储复杂类型和大量元素的情况下，list比vector更有优势！

 

使用时要包含list头文件( #include<list> )，要命名限定std::list。

 

一、构造、析构函数、= 运算符

1、功能：声明list容器。4种方式

  list<int> first;                              //空的int类型的链表

 list<int> second (4,100);                      // 4元素都为100的链表

 list<int> third (second.begin(),second.end());     //遍历第二个链表

 list<int> fourth (third);                      // 第三个链表的副本

2、功能：注销list。 ~list ();   

3、原型：list1 = list2;

功能：将list2赋值给list1，包括list2的所有元素以及list2的size

返回值：指针

 

二、返回迭代器类的函数

begin、end 、rbegin、rend

举例：  

       begin指向第一个元素，黄色箭头。end是最后一个元素的后一个位置，黑色箭头。begin和end一般一起使用，按正序输出list。rbegin指逆序的第一个元素，即最后一个元素，蓝色箭头。rend指逆序的最后一个元素的前一个位置，即第一个元素的前一个位置，红色箭头。

Rbegin和rend一般一起使用，用于逆序输出list。

 

三、list的容量相关的函数

1、empty

原型：bool empty( ) const;

功能：判断lsit是否为空，即size是否为0

返回值：size为0，返回true，否则，返回false

2、size

原型：size_typesize() const;

功能：返回lsit中元素的个数

返回值：size_type

3、Max_size

原型：size_typemax_size () const;

功能：返回lsit的最大容量

返回值：

4、resize

原型：void resize( size_type sz, T c = T())；

功能：重新分配lsit的大小。如果sz小于目前的size就将多余的值删除；如果sz大于目前的size，就在增加容量，且用c填充。例如：

mylist.resize(5);        //将size定为5

mylist.resize(8,100);  //将size定为8，多出的用100填充

mylist.resize(12);      //将size定为12

 

四、获取元素

1、front

原型：referencefront ( );

功能：获取第一个元素

返回值：第一个元素的值

2、back

原型：referenceback ( );

const_reference back ( ) const

功能：获取最后一个元素

返回值：最后一个元素

 

五、修改lsit的函数

1、assign

原型：void assign( InputIterator first, InputIterator last );

               void assign ( size_type n, constT& u)

功能：为list重新分配空间并赋值。将[first,last)范围内的值或者n次u值的拷贝赋给list

返回值：无

2、push_front：从头插入一个元素，pop_front：删除第一个元素。

push_back：在尾部插入一个元素，pop_back：删除最后一个元素。

3、insert

原型：iteratorinsert ( iterator position, const T& x );

   void insert ( iterator position, size_type n, const T& x );

template <class InputIterator>

   void insert ( iterator position, InputIterator first, InputIterator last);

功能：插入元素

insert ( iterator position, const T& x) ：在position位置处插入元素x

insert ( iterator position, size_type n,const T& x )：在position位置处开始插入n个x

insert ( iterator position, InputIteratorfirst, InputIterator last )：在position位置处开始插入

[first，last)范围内的元素。

返回值：只有第一个函数返回插入的元素所在位置

4、erase

原型：iteratorerase ( iterator position );

     iterator erase ( iterator first, iterator last );

功能：清除链表中position处或者[first,last)范围内的元素。会减少list的size值。

返回值：清除的最后一个元素的下一个位置(迭代器)

5、swap

原型：void swap (list<T,Allocator>& lst)

功能：将两个lsit交换

6、clear

功能：清空list

 

六、操作类的函数

1、splice

原型：设list2调用了splice函数

void splice ( iterator position,list<T,Allocator>& x );将list x中的所有元素插入到调用该函数的list2的position处。List x会被清空。

void splice ( iterator position,list<T,Allocator>& x, iterator i );将x中指向i的位置处的元素插入到list2的position处。X会将i位置处的值删除。

void splice ( iterator position,list<T,Allocator>& x, iterator first, iterator last ); 将x中[first,last)位置处的元素插入到list2的position处。

 

功能：Moveelements from list to list。将一个lsit中的值移动到另一个list

2、remove

原型：void remove( const T& value );

功能：清除链表中特定的值value，lsit的size会相应减少。

返回值：无

3、remove_if

原型：template<class Predicate>

     void remove_if ( Predicate pred );

功能：在满足Predicatepred返回true值时，移除元素。pred可以是一个返回bool类型的函数，还可以是一个重写operator函数的类。    例如：

// 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; }

};

返回值：无

4、unique

原型：void unique( );

template <class BinaryPredicate>

 void unique ( BinaryPredicate binary_pred );按照规则binary_pred消除重复值。例如：

bool same_integral_part (double first,double second)

{ return ( int(first)==int(second) ); }

 

// a binary predicate implemented as aclass:

class is_near

{

public:

 bool operator() (double first, double second)

  {return (fabs(first-second)<5.0); }

};

调用：mylist.unique(same_integral_part);

 mylist.unique (is_near());

功能：消除list中的重复元素

返回值：

5、merge

原型：void merge( list<T,Allocator>& x );

template <class Compare>

 void merge ( list<T,Allocator>& x, Compare comp );

功能：合并两个已经有序（同时为升序或降序）的list。

merge（）组合起两个排好序的表。如果一个表未排序，merge（）仍然能产生出一个表，其中包含着原来两个表元素的并集。当然，对结果的排序就没有任何保证了。向splice（）函数一样，merge（）函数也不复制元素。

merge函数的作用是：将两个有序的序列合并为一个有序的序列。函数参数：merge(first1,last1,first2,last2,result,compare);//firs1t为第一个容器的首迭代器，last1为第一个容器的末迭代器，first2为第二个容器的首迭代器，last2为容器的末迭代器，result为存放结果的容器，comapre为比较函数（可略写，默认为合并为一个升序序列）。

返回值：

6、sort

原型：void sort ();

template <class Compare>

 void sort ( Compare comp );

功能：排序

返回值：

7、reverse

功能：将list中的元素逆置。

返回值：

 

总结：

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中重复的元素

实例：

#include <iostream>#include <list>       //头文件 <list>#include <numeric>#include <algorithm>using namespace std;       typedef list<int> LISTINT;    //创建一个list容器的实例LISTINTtypedef list<char> LISTCHAR;  //创建一个list容器的实例LISTCHARint main(){    LISTINT listOne;      //用LISTINT创建一个名为listOne的list对象    LISTINT::iterator i;    //声明i为迭代器    listOne.push_front (2);   //从前面向listOne容器中添加数据    listOne.push_front (1);    listOne.push_back (3);    //从后面向listOne容器中添加数据    listOne.push_back (4);    cout<<"listOne.begin()--- listOne.end():"<<endl;    for (i = listOne.begin(); i != listOne.end(); ++i)      //从前向后显示listOne中的数据        cout << *i << " ";    cout << endl;    LISTINT::reverse_iterator ir;    cout<<"listOne.rbegin()---listOne.rend():"<<endl;    for (ir =listOne.rbegin(); ir!=listOne.rend();ir++)     //从后向前显示listOne中的数据        cout << *ir << " ";    cout << endl;    int Sum = accumulate(listOne.begin(), listOne.end(),0);    //使用STL的accumulate(累加)算法    cout<<"Sum="<<Sum<<endl;       LISTCHAR listTwo;   //用LISTCHAR创建一个名为listOne的list对象    LISTCHAR::iterator j;    //声明i为迭代器      listTwo.push_front ('A');    //从前面向listTwo容器中添加数据    listTwo.push_front ('B');      listTwo.push_back ('x');   //从后面向listTwo容器中添加数据    listTwo.push_back ('y');    cout<<"listTwo.begin()---listTwo.end():"<<endl;    for (j = listTwo.begin(); j != listTwo.end(); ++j)      //从前向后显示listTwo中的数据        cout << char(*j) << " ";    cout << endl;    j=max_element(listTwo.begin(),listTwo.end());      //使用STL的max_element算法求listTwo中的最大元素并显示    cout << "The maximum element in listTwo is: "<<char(*j)<<endl;return 0;}