c++list容器

list是线性双向链表结构，它的数据由若干个节点构成，每一个节点都包括一个信息块（即实际存储的数据）、一个前驱指针和一个后驱指针。它无需分配指定的内存大小且可以任意伸缩，这是因为它存储在非连续的内存空间中，并且由指针将有序的元素链接起来。由于其结构的原因，list 随机检索的性能非常的不好，因为它不像vector 那样直接找到元素的地址，而是要从头一个一个的顺序查找，这样目标元素越靠后，它的检索时间就越长。检索时间与目标元素的位置成正比。虽然随机检索的速度不够快，但是它可以迅速地在任何节点进行插入和删除操作。因为list 的每个节点保存着它在链表中的位置，插入或删除一个元素仅对最多三个元素有所影响，不像vector 会对操作点之后的所有元素的存储地址都有所影响，这一点是vector 不可比拟的。

list 的特点：

(1) 不使用连续的内存空间，这样可以随意地进行动态操作；
(2) 可以在内部任何位置快速地插入或删除，当然也可以在两端进行push 和pop 。
(3) 不能进行内部的随机访问，即不支持[ ] 操作符和vector.at() ；
(4) 相对于verctor 占用更多的内存。

 成员函数

1.Iterator:  （可用于遍历list）

iterator begin();  //返回指向第一个元素的迭代器

iterator end();  //返回指向最后一个元素的迭代器

reverse_iterator rbegin();  //返回指向第一个元素的逆向迭代器

reverse_rend();  //返回指向最后一个元素的逆向迭代器

2.Capacity: （用于获取list容器大小信息）

bool empty() const;  //list为空时返回true

size_type size() const;  //返回list容器里元素的个数

size_type max_size() const;  //返回list容器最大能容纳的元素的个数，主要用于调用list的resize()函数时，检查所请求的size大小是否被允许

3.Element access:（用于获取首尾元素）

reference front();  //返回第一个元素的引用

const_reference front() const;

reference back();  //返回最后一个元素的引用

const_reference front() const;

4.Modifiers:

（1）asign  //给容器添加新内容：

template<class InputIterator>

void assign(InputIterator first, InputIterator last); 

//first,last是一个序列中起始和结束的迭代器的值，[first, last)包含了序列中所有元素

void assign(size_type n, const value_type& val);  //给list赋值n个值为val的元素

（2）push_front, pop_front, push_back, pop_back

void push_front(const value_type& val);  //在list头添加元素

void pop_front();  //删除list头的元素

void push_back(const value_type& val);  //在list尾添加元素

void pop_back();  //删除list尾的元素

（3）insert  //插入元素：

iterator insert (iterator position, const value_type& val);  //position是要插入的这个list的迭代器，val是要插入的值

void insert (iterator position, size_type n, const value_type& val);  //从该list容器中的position位置处开始，插入n个值为val的元素

template <class InputIterator>

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

//first，last是我们选择的把值插入到这个list中的值所在的容器的迭代器

（4）erase  //删除元素：

iterator erase (iterator position);  //删除迭代器position指向的值，也可以不用变量接收其返回值

iterator erase (iterator first, iterator last);  //删除[first, last)中的值，也可以不用变量接收其返回值

（5）swap  //交换两个list的内容

void swap(list& x);  //要交换的两个列表的存储的元素的类型必须是一样的，列表大小可以不同

（6）resize  //调整list大小

void resize (size_type n, value_type val = value_type()); 

//将list大小调整为能容纳n个元素，若n大于当前list大小，则会从list末尾一直插入val值，直到list大小满足n;

（7）clear  //清空list

void clear();  //删除list的所有元素

5.Operations:

（1）splice  //将一个list中的值移到另一个list中

void splice (iterator position, list& x); 

//将列表x中的所有元素移到当前list中，从当前列表的position指向的位置开始，此时列表x为空

void splice (iterator position, list& x, iterator i);  //将列表x中迭代器 i 指向的元素移到当前list的position指向的位置处，由于i指向的元素从列表x中被移除，所以迭代器 i 此时是invalid的；position是当前列表的迭代器，i是列表x的迭代器

void splice (iterator position, list& x, iterator first, iterator last);  //将列表x中[first, last)的元素移到当前list中，从position指向的位置开始；first, last是列表x的迭代器

（2）remove  //删除list中特定的值

void remove (const value_type& val);  //从list中删除所有值为val的元素

（3）remove_if  //按条件删除

template <class Predicate>

void remove_if (Predicate pred)；  //pred可以是一个函数，也可以是一个class，但它需要有一个参数，且参数类型跟list中存储元素类型相同，满足条件就返回true

（4）unique  //删除重复值

void unique();  //只能删除相邻的重复元素，然后保留第一个值，因此这个函数只对排好序的list有用

template <class BinaryPredicate>

void unique (BinaryPredicate binary_pred);  //binary_pred可以是函数，也可以是class，但它需要有两个参数，且类型跟list中存储的值类型相同，满足某个条件就返回true

（5）merge  //合并有序的list

void merge(list &x);  //会将列表x中的元素按默认的顺序移入当前列表当中，此时列表x为空，当前列表仍为有序列表

template<class Compare>

void merge (list& x, Compare comp);  //comp可以为一个函数，要求有两个参数且参数类型跟list中存储的元素类型相同，当满足条件时返回true，merge就按照这个条件将两个列表合并

（6）sort  //排序

void sort();  //默认升序排列

template <class Compare>

void sort (Compare comp);  //comp可以是一个函数，要求有两个参数，类型跟list中元素类型相同，满足条件时返回true，sort()函数就按照comp中制定的规则对元素进行排序

（7）reverse  //逆序：

void reverse();  //将list中元素的顺序逆转过来

6.Observers:

get_allocator  //返回一个跟该list有关的分配器对象

allocator_type get_allocator() const;  //可以用来给数组动态分配空间

#include<iostream>
using namespace std;
#include<list>


void main71()
{
    list<int> l;
    cout << "list的大小：" << l.size() << endl;
    for (int i = 0; i < 10; i++)
    {
        l.push_back(i + 1);//尾插法
    }

    cout << "list的大小：" << l.size() << endl;
    list<int>::iterator it = l.begin();
    while (it != l.end())
    {
        cout << *it << " ";
        it++;
    }
    cout << endl;
    //list 不能随机访问
    it = l.begin();
    it++;
    it++;
    //it = it + 5;报错 不支持随机的访问
    l.insert(it, 100);//insert插入到迭代器当前指向的节点的后面
    for (list<int>::iterator it = l.begin(); it != l.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
    //1.链表的节点的index是从0开始的
    //2.在2号位置插入元素 是让原来的2号位置变成三号位置 就是插入到当前位置之后
}
//删除节点
void main72()
{
    list<int> l;
    cout << "list的大小：" << l.size() << endl;
    for (int i = 0; i < 10; i++)
    {
        l.push_back(i + 1);//尾插法
    }

    for (list<int>::iterator it = l.begin(); it != l.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
    cout << "list的大小：" << l.size() << endl;

    list<int>::iterator it1 = l.begin();
    list<int>::iterator it2 = l.begin();
    it2++;
    it2++;
    it2++;
    l.erase(it1, it2);
    for (list<int>::iterator it = l.begin(); it != l.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
    l.insert(l.begin(), 100);
    l.insert(l.begin(), 100);
    l.insert(l.begin(), 100);
    for (list<int>::iterator it = l.begin(); it != l.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
    l.erase(l.begin());//删除第一个一百
    for (list<int>::iterator it = l.begin(); it != l.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
    l.remove(100);//删除剩下所有的一百
    for (list<int>::iterator it = l.begin(); it != l.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;

}
int main()
{
    main72();

    system("pause");
    return 0;
}