C++ STL list

std::list

<list>

列表性质

  1、双向链表

  2、只支持双向顺序访问，不支持下标访问（随机访问迭代器）（元素随机访问）

  3、因为不支持随机访问迭代器，所以不能使用std::sort进行排序，需要调用成员函数list::sort

  4、在list中任何位置进行插入/删除操作速度都很快

容器操作

1、类型别名

2、构造列表

 1)、默认构造

    list<int> mylist;

 2)、填充构造

构造一个含有 n 个元素的容器， 每一个元素被赋值为 val（如果存在 val）

    list<int> mylist (5); // 含有 5 个元素，每个元素都被执行了默认初始化 （0）

    list<int> mylist ( 5, 1314 ); // 含有 5 个元素，每个元素的值都是 1314

 3)、范围构造

构造一个容器，具有和范围 [ first, last ) 一样多数量的元素，并且容器内元素顺序与范围内元素顺序对应

    int myints[5] = { 75, 23, 65, 42, 13 };

    list<int> mylist ( myints, myints + 5 ); // 构造一个 list 容器，元素为 myints 内的元素的副本

 4)、拷贝构造

构造一个与mylist中的元素与元素顺序相同的容器

    list<int> mylist (5， 1314);

    list<int> yourlist ( mylist ); // 将 mylist 的元素拷贝给 yourlist

 5)、列表构造（列表元素初始化）

构造一个与il中的元素与元素顺序相同的容器，initializer_list即{ }

    /* 三种写法相同 */

    list<int> mylist ( {1, 3, 5} );  //mylist 内的元素为1， 3， 5

    list<int> mylist {1, 3, 5};

    list<int> mylist = {1, 3, 5}; // 下文 `赋值`中会说明‘=’的作用

3、赋值 (=)

 1)拷贝

将 列表x 拷贝给 列表mylist

    list<int> mylist ( {1, 3, 5} );
    // 不需要提前给 x 分配大小 因为 ‘=’ 会把 mylist 中的元素信息全部拷贝过去
    list<int> x;

    x = mylist;

 2)列表拷贝

通过列表拷贝 initializer_list即{ }

    list<int> mylist(3);
    // 注意要为 mylist 分配大小
    mylist = {1, 2, 3};

4、迭代器

 1)begin

 2)end

用法举例：

#include <iostream>
#include <list>

using namespace std;

int main ( void )
{
    list<int> lk;

    for ( int i = 1; i <= 5; i++ ) // 1, 2, 3, 4, 5
        lk.push_back(i);

    for ( auto i = lk.begin(); i != lk.end(); i++ )
        cout << *i << " ";

    cout << endl;

    return 0;
}

 4)cbegin

 5)cend

 5)rbegin

 6)rend

 7)crbegin

 8)crend

5、空间

 1)empty

 2)size

 3)max_size

6、访问元素

 1)front

 2)back

7、修改

 1)assign

assign也是一种赋值方式，和初始化与赋值不同的是：assign允许我们从一个不同但相容类型赋值，或者从容器的一个子序列赋值。

assign操作用参数所指定的元素（的拷贝）替换左边容器中的所有元素。

例如，我们可以用assign实现将一个vector中的一段char*值赋予一个list中的string：

#include <iostream>
#include <list>
#include <vector>

using namespace std;

int main ( void )
{
    list<string> myString;

    vector<char*> myChar;

    myChar.push_back ( "1 2 3 4 5 6" );
    myChar.push_back ( "7 8 9 10" );
    myChar.push_back ( "11 12 13 14" );

    myString.assign ( myChar.begin(), myChar.end() );         //可以将 char* 转换为 string

    for ( auto i = myString.begin(); i != myString.end(); i++ )
    {
        cout << *i << ' ';
    }

    cout << endl;

    return 0;
}

这段代码中对assign的调用将names中的元素替换为迭代器指定的范围中的元素的拷贝。
assign的参数决定了容器中将有多少个元素以及它们的值都是什么。
输出

（1）范围赋予

（2）填充赋予

接受一个整数值和一个元素值。它用指定数目且具有相同给定值的元素替换容器中原有的元素

（3）列表元素赋予

接受一段元素列表，将list容器中的元素和大小按序替换为该元素列表内的值和个数

 2)emplace

 3)emplace_front

 4)emplace_back

来救救蒟蒻吧，emplace没学懂，欢迎留言补充交流

 5)push_front

在list容器的头部创建一个值为val的元素，相应地使size增大了1

 6)pop_front

删除list容器的的首元素

 7)push_back

在list容器的尾部创建一个值为val的元素，相应地使size增大了1

 8)pop_back

删除list容器的的尾元素

 9)insert

（1）插入单个元素

在迭代器position指向的元素之前创建一个值为val的元素，返回指向新添加的元素的迭代器

（2）插入 n 个相同元素

在迭代器position指向的元素之前插入n个值为val的元素，返回指向新添加的一个元素的迭代器；若n为0，则返回p

（3）插入元素值列表 { a, b, c, ... }

il是一个花括号包围的元素值列表。将这些给定值插入到迭代器position指向的元素之前。返回指向新添加的第一个元素的迭代器；若列表为空，则返回p

 10)erase

 ａ.删除单个元素

删除由一个迭代器指定的单个元素

返回指向删除的元素之后位置的迭代器

 ｂ.删除多个元素

接受一对迭代器，允许我们删除一个范围内的元素
迭代器first指向要删除的第一个元素，last指向我们要删除的最后一个元素之后的位置

 11)swap

用于交换容器内容，swap交换两个list容器内部的数据结构（元素本身并未交换），所以非常快，可以保证在常数时间内完成。

 12)resize

将容器的大小变为n

1、如果n小于当前容器的大小，则将元素个数减少到前n个元素，并删除超出范围的元素。

2、如果n大于当前容器的大小，则通过在末尾插入任意数量的元素以达到n个元素。

如果指定了val，则将新元素初始化为val的副本，否则，将对它们进行值的默认初始化。

 13)clear

删除list容器中所有元素
void clear ( void )

8、操作

 1)splice

例如有lista，listb
则splice的作用是将b中的某些元素移动到a当中的某个位置去

 a.移动所有元素

将x容器中的所有元素移动到指定容器的迭代器position所指向的位置。

插入的第一个元素置于迭代器position所指向的位置

原先位置的元素置于被插入的最后一个元素的后面。（两容器的大小均已改变）

注意和insert的区别，splice相当是把元素插入在了position的前面

 c.单一元素移动

将x容器中,迭代器i所指向的元素移动到list容器中,迭代器position所指向的位置之前.

 c.范围元素移动

将范围[first，last）内的元素从x移动到list容器中position所指向的位置之前。

关于splice的具体操作请见代码：

// splicing lists
#include <iostream>
#include <list>

int main ()
{
  std::list<int> mylist1, mylist2;
  std::list<int>::iterator it;

  // set some initial values:
  for (int i=1; i<=4; ++i)
     mylist1.push_back(i);      // mylist1: 1 2 3 4

  for (int i=1; i<=3; ++i)
     mylist2.push_back(i*10);   // mylist2: 10 20 30

  it = mylist1.begin();
  ++it;                         // points to 2

  mylist1.splice (it, mylist2); // mylist1: 1 10 20 30 2 3 4
                                // mylist2 (empty)
                                // "it" still points to 2 (the 5th element)

  mylist2.splice (mylist2.begin(),mylist1, it);
                                // mylist1: 1 10 20 30 3 4
                                // mylist2: 2
                                // "it" is now invalid.
  it = mylist1.begin();
  std::advance(it,3);           // "it" points now to 30

  mylist1.splice ( mylist1.begin(), mylist1, it, mylist1.end());
                                // mylist1: 30 3 4 1 10 20

  std::cout << "mylist1 contains:";
  for (it=mylist1.begin(); it!=mylist1.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  std::cout << "mylist2 contains:";
  for (it=mylist2.begin(); it!=mylist2.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

OutPut:

mylist1 contains: 30 3 4 1 10 20
mylist2 contains: 2

 2)remove

删除具有val的元素

 3)remove_if

删除满足条件的元素

// list::remove_if
#include <iostream>
#include <list>

// a predicate implemented as a function:
bool single_digit (const int& value) { return (value<10); }

// a predicate implemented as a class:
struct is_odd {
  bool operator() (const int& value) { return (value%2)==1; }
};

int main ()
{
  int myints[]= {15,36,7,17,20,39,4,1};
  std::list<int> mylist (myints,myints+8);   // 15 36 7 17 20 39 4 1

  mylist.remove_if (single_digit);           // 15 36 17 20 39

  mylist.remove_if (is_odd());               // 36 20

  std::cout << "mylist contains:";
  for (std::list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

OutPut:

mylist contains: 36 20

 4)unique

删除相邻重重元素,是真的销毁掉.

 5)merge

拼接list容器

 a.拼接

 b.带有比较模板的拼接

 6)sort

对list容器进行排序

 a.升序排序 // 0, 1, 2, 3, 4

 b.cmp模板排序

 7)reverse

反转list容器中元素的顺序