C++中list用法详解

最新推荐文章于 2025-06-30 12:42:15 发布

转载最新推荐文章于 2025-06-30 12:42:15 发布 · 880 阅读

文章标签：

#c++

c++ 专栏收录该内容

49 篇文章

订阅专栏

原文地址：http://blog.youkuaiyun.com/yas12345678/article/details/52601578

http://blog.youkuaiyun.com/lskyne/article/details/10418823/

1.关于list容器

我想把三个常用的序列式放在一起对比一下是有必要的：

vector ： vector和built-in数组类似，拥有一段连续的内存空间，能非常好的支持随即存取，即[]操作符，但由于它的内存空间是连续的，所以在中间进行插入和删除会造成内存块的拷贝，另外，当插入较多的元素后，预留内存空间可能不够，需要重新申请一块足够大的内存并把原来的数据拷贝到新的内存空间。这些影响了vector的效率，但是实际上用的最多的还是vector容器，建议大多数时候使用vector效率一般是不错的。vector的用法解析可以参考本人的另一篇随笔：http://www.cnblogs.com/BeyondAnyTime/archive/2012/08/08/2627666.html

list： list就是数据结构中的双向链表(根据sgi stl源代码)，因此它的内存空间是不连续的，通过指针来进行数据的访问，这个特点使得它的随即存取变的非常没有效率，因此它没有提供[]操作符的重载。但由于链表的特点，它可以以很好的效率支持任意地方的删除和插入。

deque： deque是一个double-ended queue，它的具体实现不太清楚，但知道它具有以下两个特点：它支持[]操作符，也就是支持随即存取，并且和vector的效率相差无几，它支持在两端的操作：push_back,push_front,pop_back,pop_front等，并且在两端操作上与list的效率也差不多。

因此在实际使用时，如何选择这三个容器中哪一个，应根据你的需要而定，具体可以遵循下面的原则：
1. 如果你需要高效的随即存取，而不在乎插入和删除的效率，使用vector
2. 如果你需要大量的插入和删除，而不关心随即存取，则应使用list
3. 如果你需要随即存取，而且关心两端数据的插入和删除，则应使用deque。

2.list中常用的函数

2.1list中的构造函数：

list() 声明一个空列表；

list(n) 声明一个有n个元素的列表，每个元素都是由其默认构造函数T()构造出来的

list(n,val) 声明一个由n个元素的列表，每个元素都是由其复制构造函数T(val)得来的

list(n,val) 声明一个和上面一样的列表

list(first,last) 声明一个列表，其元素的初始值来源于由区间所指定的序列中的元素

2.2 begin()和end():

通过调用list容器的成员函数begin()得到一个指向容器起始位置的iterator，可以调用list容器的 end() 函数来得到list末端下一位置，相当于：int a[n]中的第n+1个位置a[n]，实际上是不存在的，不能访问，经常作为循环结束判断结束条件使用。

2.3 push_back() 和push_front()：

使用list的成员函数push_back和push_front插入一个元素到list中。其中push_back()从list的末端插入，而 push_front()实现的从list的头部插入。

2.4 empty()：

利用empty() 判断list是否为空。

2.5 resize()：

如果调用resize(n)将list的长度改为只容纳n个元素，超出的元素将被删除，如果需要扩展那么调用默认构造函数T()将元素加到list末端。如果调用resize(n,val)，则扩展元素要调用构造函数T(val)函数进行元素构造，其余部分相同。

2.6 clear()：

清空list中的所有元素。

2.7 front()和back()：

通过front()可以获得list容器中的头部元素，通过back()可以获得list容器的最后一个元素。但是有一点要注意，就是list中元素是空的时候，这时候调用front()和back()会发生什么呢？实际上会发生不能正常读取数据的情况，但是这并不报错，那我们编程序时就要注意了，个人觉得在使用之前最好先调用empty()函数判断list是否为空。

2.8 pop_back和pop_front()：

通过删除最后一个元素，通过pop_front()删除第一个元素；序列必须不为空，如果当list为空的时候调用pop_back()和pop_front()会使程序崩掉。

2.9 assign()：

具体和vector中的操作类似，也是有两种情况，第一种是：l1.assign(n,val)将 l1中元素变为n个T(val）。第二种情况是：l1.assign(l2.begin(),l2.end())将l2中的从l2.begin()到l2.end()之间的数值赋值给l1。

2.10 swap()：

交换两个链表(两个重载)，一个是l1.swap(l2); 另外一个是swap(l1,l2)，都可能完成连个链表的交换。

2.11 reverse()：

通过reverse()完成list的逆置。

2.12 merge()：

合并两个链表并使之默认升序(也可改)，l1.merge(l2，greater<int>()); 调用结束后l2变为空，l1中元素包含原来l1 和 l2中的元素，并且排好序，升序。其实默认是升序，greater<int>()可以省略，另外greater<int>()是可以变的，也可以不按升序排列。

看一下下面的程序：

  #include <iostream>
  #include <list>
  
  using namespace std;
  
  int main()
  {
     list<int> l1;
     list<int> l2(2,0);
     list<int>::iterator iter;
     l1.push_back(1);
     l1.push_back(2);
     l2.push_back(3);
     l1.merge(l2,greater<int>());//合并后升序排列，实际上默认就是升序
     for(iter = l1.begin() ; iter != l1.end() ; iter++)
     {
         cout<<*iter<<" ";
     }
     cout<<endl<<endl;
     if(l2.empty())
     {
         cout<<"l2 变为空 ！！";
     }
     cout<<endl<<endl;
     return 0;
 }

运行结果：

1 2 0 0 3

l2 变为空！！

2.13 insert()：

在指定位置插入一个或多个元素(三个重载)：

l1.insert(l1.begin(),100); 在l1的开始位置插入100。

l1.insert(l1.begin(),2,200); 在l1的开始位置插入2个100。

l1.insert(l1.begin(),l2.begin(),l2.end());在l1的开始位置插入l2的从开始到结束的所有位置的元素。

2.14 erase()：

删除一个元素或一个区域的元素(两个重载)

l1.erase(l1.begin()); 将l1的第一个元素删除。

l1.erase(l1.begin(),l1.end()); 将l1的从begin()到end()之间的元素删除。

3.list中常用的函数（补充）

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

4.list实例

4.1实例1：

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

结果：

listOne.begin()--- listOne.end():
1 2 3 4
listOne.rbegin()---listOne.rend():
4 3 2 1
Sum=10
------------------
listTwo.begin()---listTwo.end():
B A x y
The maximum element in listTwo is: y
Press any key to continue

4.2实例2：

#include <iostream>   
#include <list>   
  
using namespace std;   
typedef list<int> INTLIST;   
  
//从前向后显示list队列的全部元素   
void put_list(INTLIST list, char *name)   
{   
    INTLIST::iterator plist;   
      
    cout << "The contents of " << name << " : ";   
    for(plist = list.begin(); plist != list.end(); plist++)   
        cout << *plist << " ";   
    cout<<endl;   
}   
  
//测试list容器的功能   
void main(void)   
{   
    //list1对象初始为空   
    INTLIST list1;   
    //list2对象最初有10个值为6的元素   
    INTLIST list2(10,6);   
    //list3对象最初有3个值为6的元素   
    INTLIST list3(list2.begin(),--list2.end());   
      
    //声明一个名为i的双向迭代器   
    INTLIST::iterator i;   
      
    //从前向后显示各list对象的元素   
    put_list(list1,"list1");   
    put_list(list2,"list2");   
    put_list(list3,"list3");   
      
    //从list1序列后面添加两个元素   
    list1.push_back(2);   
    list1.push_back(4);   
    cout<<"list1.push_back(2) and list1.push_back(4):"<<endl;   
    put_list(list1,"list1");   
      
    //从list1序列前面添加两个元素   
    list1.push_front(5);   
    list1.push_front(7);   
    cout<<"list1.push_front(5) and list1.push_front(7):"<<endl;   
    put_list(list1,"list1");   
      
    //在list1序列中间插入数据   
    list1.insert(++list1.begin(),3,9);   
    cout<<"list1.insert(list1.begin()+1,3,9):"<<endl;   
    put_list(list1,"list1");   
      
    //测试引用类函数   
    cout<<"list1.front()="<<list1.front()<<endl;   
    cout<<"list1.back()="<<list1.back()<<endl;   
      
    //从list1序列的前后各移去一个元素   
    list1.pop_front();   
    list1.pop_back();   
    cout<<"list1.pop_front() and list1.pop_back():"<<endl;   
    put_list(list1,"list1");   
      
    //清除list1中的第2个元素   
    list1.erase(++list1.begin());   
    cout<<"list1.erase(++list1.begin()):"<<endl;   
    put_list(list1,"list1");   
      
    //对list2赋值并显示   
    list2.assign(8,1);   
    cout<<"list2.assign(8,1):"<<endl;   
    put_list(list2,"list2");   
      
    //显示序列的状态信息   
    cout<<"list1.max_size(): "<<list1.max_size()<<endl;   
    cout<<"list1.size(): "<<list1.size()<<endl;   
    cout<<"list1.empty(): "<<list1.empty()<<endl;   
      
    //list序列容器的运算   
    put_list(list1,"list1");   
    put_list(list3,"list3");   
    cout<<"list1>list3: "<<(list1>list3)<<endl;   
    cout<<"list1<list3: "<<(list1<list3)<<endl;   
      
    //对list1容器排序   
    list1.sort();   
    put_list(list1,"list1");   
      
    //结合处理   
    list1.splice(++list1.begin(), list3);   
    put_list(list1,"list1");   
    put_list(list3,"list3");   
}

结果：

The contents of list1 :
The contents of list2 : 6 6 6 6 6 6 6 6 6 6
The contents of list3 : 6 6 6 6 6 6 6 6 6
list1.push_back(2) and list1.push_back(4):
The contents of list1 : 2 4
list1.push_front(5) and list1.push_front(7):
The contents of list1 : 7 5 2 4
list1.insert(list1.begin()+1,3,9):
The contents of list1 : 7 9 9 9 5 2 4
list1.front()=7
list1.back()=4
list1.pop_front() and list1.pop_back():
The contents of list1 : 9 9 9 5 2
list1.erase(++list1.begin()):
The contents of list1 : 9 9 5 2
list2.assign(8,1):
The contents of list2 : 1 1 1 1 1 1 1 1
list1.max_size(): 1073741823
list1.size(): 4
list1.empty(): 0
The contents of list1 : 9 9 5 2
The contents of list3 : 6 6 6 6 6 6 6 6 6
list1>list3: 1
list1<list3: 0
The contents of list1 : 2 5 9 9
The contents of list1 : 2 6 6 6 6 6 6 6 6 6 5 9 9
The contents of list3 :
Press any key to continue