C++之STL-3-list

一.定义

List

Lists are sequence containers that allow constant time insert and erase operations anywhere within the sequence, and iteration in both directions.

lists 是一种能够在常数阶时间（O(1)）内对序列进行插入和删除操作的线性容器，并且在两个方向上都具有迭代器。

List containers are implemented as doubly-linked lists; Doubly linked lists can store each of the elements they contain in different and unrelated storage locations. The ordering is kept internally by the association to each element of a link to the element preceding it and a link to the element following it.

List 容器经由双向链表实现；双向链表能够将它们的元素存储在不同或者不相关内存地址上。List中元素的顺序由与之相关联的前一个元素和后一个元素保存。

They are very similar to forward_list The main difference being that forward_list objects are single-linked lists, and thus they can only be iterated forwards, in exchange for being somewhat smaller and more efficient.

List 与 forward_list 非常相似。最大的不同在于 forward_lists 是单向链表，因此它可以只需要一个前向的迭代器，随之而来的是更加精简和高效。

Compared to other base standard sequence containers (array, vector and deque), lists perform generally better in inserting, extracting and moving elements in any position within the container for which an iterator has already been obtained, and therefore also in algorithms that make intensive use of these, like sorting algorithms.

与其他标准的线性容器相比（array,vector 和deque），list 通常在插入，获取，以及在容器内部任意位置移动已经获得迭代器的元素表现更好，因此也是大量使用在这些元素的算法中: 如排序算法

The main drawback of lists and forward_lists compared to these other sequence containers is that they lack direct access to the elements by their position; For example, to access the sixth element in a list, one has to iterate from a known position (like the beginning or the end) to that position, which takes linear time in the distance between these. They also consume some extra memory to keep the linking information associated to each element (which may be an important factor for large lists of small-sized elements).

lists 和 forward_lists 的主要缺点是它们无法通过位置直接访问元素; 例如：访问列表中的第六个元素，必须从已知位置（如开始或结束）迭代到该位置，该位置到这些位置之间的距离消耗线性阶时间（O(n))。它们还消耗一些额外的内存来保持与每个元素相关联的链接信息（这可能是大型列表小型元素的重要因素）。

二.主要操作

1>声明/构造

操作	作用
list<Type> e	产生一个空的list
list<Type> e1(e2)	产生一个e2同型的list，每个元素都被复制
list<Type> e(n)	产生一个n个元素的list，每个元素都由default构造产生
list<Type> e(n,elem)	产生一个n个元素的list，每个元素都是elem的副本
list<Type> e(begin,end)	产生一个list以区间 [begin,end) 内所有元素作为初值

2>内存相关

e.size()	返回当前的元素数量
e.empty()	判断大小是否为零，等价于0 == size()，效率更高
e.max_size()	返回能容纳的元素最大数量

3>赋值

e1 = e2	将e2的元素全部赋值给e1
e.assign(n,elem)	将elem的n个副本拷贝给e
e.assign(begin,end)	创建一个list，区间 [begin,end) 内的所有元素作为初值
e1.swap(e2)	e1和e2元素互换
swap(e1,e2)	e1和e2元素互换，全局函数

4>获取/插入/删除/修改大小/清空

e.front()	返回第一个元素，不检查元素是否存在
e.back()	返回最后一个元素，不检查元素是否存在
e.insert(pos, elem)	在迭代器pos位置插入一个elem副本，返回新元素位置
e.insert(pos,n, elem)	在迭代器pos位置插入n个elem副本，无返回值
e.insert(pos, beg,end)	在迭代器pos位置插入区间[beg,end)内所有元素的副本，无返回值
e.push_back(elem)	在尾部追加一个elem副本
e.pop_back()	移除最后一个元素，不返回
e.push_front(elem)	在头部安插一个elem副本
e.pop_front()	移除第一个元素，不返回
e.remove(val)	移除所有值为val的元素
e.remove_if(op)	移除所有“造成op(elem)为true”的元素
e.erase(pos)	移除迭代器pos所指元素，返回下一元素位置
e.erase(beg,end)	移除区间[beg,end)内的所有元素，返回下一元素位置
e.resize(num)	将元素容量重置为num个，如果size变大，则以default构造函数构造所有元素
e.resize (num, elem)	将元素容量重置为num个，如果size变大，则所有元素为elem的副本
e. clear ()	移除所有元素，将整个容器清空

5>特殊操作

e.unique()	如果存在若干相邻而数值相等的元素，移除重复元素，只留下一个
e.unique(tag)	若存在若干相邻元素，都使tag()为true，移除重复元素，只留下一个
e1.splice(pos,e2)	将所有e2元素移到e1容器pos迭代器之前
e1.splice(pos,e2,e2pos)	将e2 pos位置元素移到e1元素pos位置，e1和e2可以相同
e1.splice(pos,e2,e2beg,e2end)	将c2区间[e2beg,e2end)所有元素移到e1 pos位置之前，e1和e2可以相同
e.sort()	以operator < 为准，对所有元素排序
e.sort(op)	以op()为准，对e排序
e1.merge(e2)	假设e1和e2已序，将e2元素移动到e1，并保证合并后的list仍为已序
e1.merge(e2,op)	假设e1和e2都以op()为序，将e2移动到e1仍然以op()已序
e.reverse()	将list中所有元素逆序

三.示例代码

#include <iostream>
#include <list>

using namespace std;

void printList(list<int> &temp);

void printList(list<int> &temp) {
    for (list<int>::iterator e = temp.begin(); e != temp.end(); e++) {
        cout << *e << " ";
    }
    cout << endl;
}

int main() {
    //声明list
    list<int> a;

    //向前面增加元素
    for (int i = 0; i < 10; i++)
        a.push_front(i);

    //向后面增加元素
    for (int i = 10; i < 15; i++)
        a.push_back(i);

    //遍历：由于list是一种双向链表，只能使用迭代器访问元素
    printList(a);

    //中间插入元素
    list<int>::iterator temp = a.insert(++a.begin(), -1);
    printList(a);

    //删除元素
    a.erase(temp);
    printList(a);

    //反转list
    a.reverse();
    printList(a);

    //排序
    a.sort();
    printList(a);

    return 0;
}

 

四.参考资料：

1>.http://www.cplusplus.com/reference

2>.https://www.cnblogs.com/ChinaHook/p/6985368.html