C++ List的使用

vector容器提供了对元素的快速随机访问,但付出的代价是在其任意位置插入和删除元素,比在容器尾部插入和删除的开销更大。 而list容器可以在任何位置快速插入和删除,但付出的代价是元素的随机访问开销更大

构造List对象

头文件： #include< List >

list<int> b;           //无参数 - 构造一个空的list,
list<int> a(10);       //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型），但没有给出初值，其值是不确定的。
list<int> a(10, 1);     //定义了10个整型元素的向量,且给出每个元素的初值为1
list<int> a(b);        //用b向量来创建a向量，整体复制性赋值， 拷贝构造
list<int> v3 = a;       //移动构造

基本操作-属性获取/调整

1 list.empty-判断list是否为空

a.empty()

2 list.size-元素的个数

a.size()

3 list.resize-调整大小

a.resize(10);        //将a的现有元素个数调至10个，多则删，少则补，其值随机
a.resize(10, 2);      //将a的现有元素个数调至10个，多则删，少则补，其值为2

4 比较操作符

a==b;     //b为向量，向量的比较操作还有!=,>=,<=,>,<

基本操作-增加元素

1 list.push_back()-尾部插入元素

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

int main ()
{
  std::list<int> mylist;
  int myint;

  std::cout << "Please enter some integers (enter 0 to end):\n";

  do {
    std::cin >> myint;
    mylist.push_back (myint);
  } while (myint);

  std::cout << "mylist stores " << mylist.size() << " numbers.\n";

  return 0;
}

2 list.insert()-插入元素

第一个函数，在迭代器指定的位置前插入值为x的元素

第二个函数，在迭代器指定的位置前插入n个值为x的元素

a.insert(a.begin(), 5);         //在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4
a.insert(a.begin(), 3, 5);       //在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5

3 list.push_front()-头部插入元素

a.push_front (200);

基本操作-删除元素

1 list.erase-删除

iterator erase (const_iterator position);//删除指定位置元素，返回迭代器
//例如：a.erase(a.begin())

iterator erase (const_iterator first, const_iterator last);//删除指定迭代器中间的元素，左闭右开
//例如：a.erase(a.begin(), a.end());

// erasing from list
#include <iostream>
#include <list>

int main ()
{
  std::list<int> mylist;
  std::list<int>::iterator it1,it2;

  // set some values:
  for (int i=1; i<10; ++i) mylist.push_back(i*10);

                              // 10 20 30 40 50 60 70 80 90
  it1 = it2 = mylist.begin(); // ^^
  advance (it2,6);            // ^                 ^
  ++it1;                      //    ^              ^

  it1 = mylist.erase (it1);   // 10 30 40 50 60 70 80 90
                              //    ^           ^

  it2 = mylist.erase (it2);   // 10 30 40 50 60 80 90
                              //    ^           ^

  ++it1;                      //       ^        ^
  --it2;                      //       ^     ^

  mylist.erase (it1,it2);     // 10 30 60 80 90
                              //        ^

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

  return 0;
}

2 list.clear-清空list中的元素

将容器里的内容清空，size值为0，但是存储空间没有改变

a.clear();

3 list.pop_back-删除尾部元素

a.pop_back();         //删除a向量的最后一个元素

4 list.pop_front-删除头部元素

a.pop_front();

基本操作-查找/修改元素

1 list.assign-重新赋值

std::list<int> first;
std::list<int> second;

first.assign (7,100);                      // 7 ints with value 100
second.assign (first.begin(),first.end()); // a copy of first
int myints[]={1776,7,4};
first.assign (myints,myints+3); xxxxxxxxxx a.assign(4,2); 

2 list.back-返回list的最后一个元素

返回尾部元素的值，与end()函数有区别，back()函数返回的是尾部元素的迭代器

list.back()

3 list.front-返回list的第一个元素

返回第一个元素的值，与begin()函数有区别，begin()函数返回的是第一个元素的迭代器

list.front()

// listtor::operator[]
#include <iostream>
#include <listtor>

int main ()
{
  std::listtor<int> mylisttor (10);   // 10 zero-initialized elements

  std::listtor<int>::size_type sz = mylisttor.size();

  // assign some values:
  for (unsigned i=0; i<sz; i++) mylisttor[i]=i;

  // reverse listtor using operator[]:
  for (unsigned i=0; i<sz/2; i++)
  {
    int temp;
    temp = mylisttor[sz-1-i];
    mylisttor[sz-1-i]=mylisttor[i];
    mylisttor[i]=temp;
  }

  std::cout << "mylisttor contains:";
  for (unsigned i=0; i<sz; i++)
    std::cout << ' ' << mylisttor[i];
  std::cout << '\n';

  return 0;
}

4 swap-交换

交换这两个容器的内容，这涉及到存储空间的重新分配

std::list<int> first (3,100);   // three ints with a value of 100
std::list<int> second (5,200);  // five ints with a value of 200

first.swap(second);

基本操作-迭代器

1 list.begin/list.end-迭代器

//遍历
for (std::list<int>::iterator it=mylist.begin(); it != mylist.end(); ++it)
    std::cout << ' ' << *it;

2 list.cbegin/list.cend-常量迭代器

返回一个类型为cont::const_iterator 的对象

#include <iostream>
#include <List>

int main ()
{
 std::list<int> mylist = {5,10,15,20};
  std::cout << "mylist contains:";
  for (auto it = mylist.cbegin(); it != mylist.cend(); ++it)
    std::cout << ' ' << *it;

  return 0;
}

算法操作

1 list.sort()

2 list.reverse() -反转

3 list.unique()-删除list中重复的元素

4 list.splice()-合并两个list

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

5 list…merge合并两个list

first.merge(second);

参考

http://www.cplusplus.com/reference/list/list/merge/