STL总结之list

介绍

list 是一个封装双向链表的顺序容器，可以高效地实现在任意位置插入或删除元素，但是无法通过其索引位置进行访问。
list 定义于头文件 <list>，其声明如下：

template<
    class T,
    class Allocator = std::allocator<T>
> class list;

list 顺序容器是一个类。

初始化

• list<T> ls;
  创建一个空的 list 容器。

  list<int> ls;
  

• list<T> ls(num);
  创建一个大小为 num 的 list 容器，且容器中的每个元素使用 T 的默认构造函数进行初始化。

  list<int> ls(5);
  

• list<T> ls(num,value);
  创建一个大小为 num 的 list 容器，且容器中的每个元素均赋初值为 value。

  list<int> ls(5,1);
  

• list<T> ls({num1,num2,……})
  创建一个以初值列元素为初值的 list 容器。

  list<int> ls({0,1,2,3});
  

• list<T> ls = {num1,num2,……}
  创建一个以初值列元素为初值的 list 容器。

  list<int> ls = {0,1,2,3};
  

• list<T> ls(ls1);
  创建一个 ls1 的同型拷贝 (所有元素都被复制)。

  list<int> ls1 = {0,1,2,3};
  list<int> ls(ls1);
  

• list<T> ls = ls1;
  创建一个 ls1 的同型拷贝 (所有元素都被复制)。

  list<int> ls1 = {0,1,2,3};
  list<int> ls = ls1;
  

• list<T> ls(begin_iterator,end_iterator)
  创建一个以迭代器区间为 [begin_iterator,end_iterator) 作为元素初值的 list 容器。

  list<int> ls1 = {0,1,2,3};
  list<int> ls(ls1.begin(),ls1.end());
  

修改

访问 list 中元素，有以下几种方式：

1. front()
   返回 list 第一个元素的引用。

     cout << ls.front() << endl;
   

2. back()
   返回 list 最后一个元素的引用。

   cout << ls.back() << endl;
   

3. 迭代器
   对此容器而言，需要遍历 list 才能访问到想要访问的元素。
   对此容器使用迭代器，有一点需要特别注意：*(++ite) 访问的是 ite 所指元素的下一个元素，而 ite = ite + 1; *ite 会出现错误，原因就在于 list 容器元素不是顺序存储的。 .

   list<int>::iterator ite = ls.begin();
   for(;ite != ls.end();++ite)
   {
        cout << *ite << " ";
   }
   

以上 3 种访问方式都可以实现修改。
其余修改方法不常用，因此放弃列举。

查询

• empty()
  判断 list 容器是否为空。
• size()
  返回 list 容器中的元素个数。
• max_size()
  返回 list 容器大小的理论极限值，即当前内存情况下，允许创建 list 容器中元素个数的最大可能值。

比较

按照字典序列比较 list 中的值。

• operator ==
• operator !=
• operator <
• operator <=
• operator >
• operator >=

if(ls == ls1)
{
	cout << "ls == ls1" << endl;
}

增加

• push_front(num)
  向 list 容器头部添加一个元素。

  ls.push_front(4);
  

• push_back(num)
  向 list 容器尾部添加一个元素。

  ls.push_back(4);
  

• insert(pos_iterator,num)
  在迭代器位置 pos_iterator 之前插入一个元素 num，并返回元素的新位置。

  ls.insert(ls.begin(),-1);
  

• insert(pos_iterator,start_iterator,end_iterator)
  在迭代器位置 pos_iterator 之前插入迭代器区间 [start_iterator,end_iterator) 内的所有元素，并返回首个被插入元素的新位置。

  list<int> ls1 = {5,4,3};
  list<int> ls = {2,1,0};
  ls.insert(ls.begin(),ls1.begin(),ls1.end());
  // 此时 list 容器元素依次为：5,4,3,2,1,0
  

删除

• pop_front()
  移除 list 容器第一个元素。

  ls.pop_front();
  

• pop_back()
  移除 list 容器最后一个元素。

  ls.pop_back();
  

• clear()
  清空 list 容器。
• erase(pos_iterator)
  删除 list 容器指定迭代器位置 pos_iterator 的元素。

  ls.erase(ls.begin());
  

• erase(start_iterator,end_iterator)
  删除 list 容器指定迭代器区间 [start_iterator,end_iterator) 中的元素。

  list<int> ls = {5,4,3,2,1,0};
  ls.erase(ls.begin(),++(++ls.begin()));
  // 此时 list 容器元素依次为： 3,2,1,0
  

其他操作

• sort(cmp)
  按照比较函数 cmp 对 list 中元素进行排序。

  bool cmp(const int& a,const int& b)
  {
    return (a < b) ? true : false;
  }
  list<int> ls = {4,3,6,1,7,1,0};
  ls.sort(cmp);
  // 此时 list 容器元素依次为：0,1,1,3,4,6,7
  

  此函数参数可以省略，此时默认采用上面的 cmp 函数进行排序，即从小到大方式排序。

• merge(ls1,cmp)
  按照比较函数 cmp 合并 ls 容器和 ls1 容器，而且合并后 ls1 容器为空。
  合并要求 ls 容器和 ls1 容器都是按照 cmp 函数进行排序好的。

  bool cmp(const int& a,const int& b)
  {
    return (a < b) ? true : false;
  }
  list<int> ls = {4,4,1,2,7,0};
  list<int> ls1 = {2,1,4,5,0};
  ls.sort(cmp);
  ls1.sort(cmp);
  ls.merge(ls1);
  // 此时 ls 容器元素依次为：0,0,1,1,2,2,4,4,4,5,7   ls1 容器元素依次： 
  

  此函数第二个参数可以省略，此时默认采用上面的 cmp 函数进行排序，即从小到大方式排序。

• reverse()
  将 list 容器所有元素位置翻转。

  list<int> ls = {1,2,3,4,5};
  ls.reverse();
  // 此时 list 容器元素依次为：5,4,3,2,1
  

• unique()
  移除 list 容器中相邻重复元素。

  list<int> ls = {1,2,3,3,2,4,5};
  ls.unique();
  // 此时 list 容器元素依次为：1,2,3,2,4,5
  

  仅移除相邻重复元素，比如例子中的 2 就不会被移除，因为不相邻。