链表--List

STL中，List（class list<>的一个实例）使用一个doubly linked list管理元素。List不支持随机访问，但任何位置上执行元素的安插和移动都非常快。

双向链表–Doubly Linked List

template<Class T>
Class DLLNode{
	public:
		DLLNode(){
			next = prev = 0;
		}
		DLLNode(const T& el, DLLNode *n = 0, DLLNode *p = 0){
			info = el; next = n; prev = p;
		}

	T info;
	DLLNode *next, *prev;
};

template<Class T>
Class DoublyLinkedList{
	public:
		DoublyLinkedList(){
			head = tail = 0;
		}

		void addToDLLTail(const T&);	// O(1)
		T deleteFromDLLTail();	// O(1)
		......
	protected:
		DLLNode<T> *head, *tail;
};

使用List时必须先包含头文件：

include <list>

其中list类型系定义于namespace std中，是个class template：

namespace std{
    template <typename T, typename Allocator = allocator<T>>
    class list;
}

初始化

操作	效果
list c	Default构造函数，产生一个空list，没有任何元素
list c(c2)	Copy构造函数，建立c2的同型list并成为c2的一份拷贝（所有元素都被复制）
list c = c2	Copy构造函数，建立一个新的list作为c2的拷贝（所有元素都被复制）
list c(rv)	Move构造函数，建立一个新的list，取rvalue rv的内容
list c = rv	Move构造函数，建立一个新的list，取rvalue rv的内容
list c(n)	利用元素的default构造函数生成一个大小为n的list
list c(n,elem)	建立一个大小为n的list，每个元素值都是elem
list c(beg,end)	建立一个list，以区间[beg,end)作为元素初值
list c(initlist)	建立一个list，以初值列initlist的元素为初值
list c = initlist	建立一个list，以初值列initlist的元素为初值
c.~list()	销毁所有元素，释放内存

非变更型操作

操作	效果
c.empty()	返回是否容器为空（相当于size()==0但也许较快）
c.size()	返回目前的元素个数
c.max_size()	返回元素个数之最大可能量
c1 == c2	返回c1是否等于c2（对每个元素调用==）
c1 != c2	返回c1是否不等于c2（相当于!(c1==c2)）
c1 < c2	返回c1是否小于c2
c1 > c2	返回c1是否大于c2（相当于c2<c1）
c1 <= c2	返回c1是否小于等于c2（相当于!(c2<c1)）
c1 >= c2	返回c1是否大于等于c2（相当于!(c1<c2)）

赋值操作

操作	效果
c = c2	将c2的全部元素赋值给c
c = rv	将rvalue rv的所有元素以move assign方式给予c
c = initlist	将初值列initlist的所有元素赋值给c
c.assign(n,elem)	复制n个elem，赋值给c
c.assign(beg,end)	将区间[beg,end)内的元素赋值给c
c.assign(initlist)	将初值列initlist的所有元素赋值给c
c1.swap(c2)	置换c1和c2的数据
swap(c1,c2)	置换c1和c2的数据

元素访问

操作	效果
c.front()	返回第一元素（不检查是否存在第一元素）
c.back()	返回最末元素（不检查是否存在最末元素）

迭代器相关函数

操作	效果
c.begin()	返回一个bidirectional iterator指向第一个元素
c.end()	返回一个bidirectional iterator指向最末元素的下一位置
c.cbegin()	返回一个const bidirectional iterator指向第一个元素
c.cend()	返回一个const bidirectional iterator指向最末元素的下一位置
c.rbegin()	返回一个反向的（reverse）iterator指向反向迭代的第一元素
c.rend()	返回一个反向的（reverse）iterator指向反向迭代的最末元素的下一位置
c.crbegin()	返回一个const reverse iterator指向反向迭代的第一元素
c.crend()	返回一个const reverse iterator指向反向迭代的最末元素的下一位置

插入与移除

操作	效果
c.push_back(elem)	附加一个elem的拷贝于末尾
c.pop_back()	移除最后一个元素，但是不返回它
c.push_front(elem)	在头部插入elem的一个拷贝
c.pop_front()	移除第一元素，但是不返回它
c.insert(pos,elem)	在iterator位置pos之前插入一个elem拷贝，并返回新元素的位置
c.insert(pos,n,elem)	在iterator位置pos之前插入n个elem拷贝，并返回第一个新元素的位置（或返回pos–如果没有新元素的话）
c.insert(pos,beg,end)	在iterator位置pos之前插入区间[beg,end)内所有元素的一份拷贝，并返回第一个新元素的位置（或返回pos–如果没有新元素的话）
c.insert(pos,initlist)	在iterator位置pos之前插入初值列initlist内所有元素的一份拷贝，并返回第一个新元素的位置（或返回pos–如果没有新元素的话
c.emplace(pos,args…)	在iterator位置pos之前插入一个以args为初值的元素，并返回新元素的位置
c.emplace_back(args…)	附加一个以args为初值的元素于末尾，不返回任何东西
c.emplace_front(args…)	插入一个以args为初值的元素于起点，不返回任何东西
c.erase(pos)	移除iterator位置pos上的元素，返回下一元素的位置
c.erase(beg,end)	移除[beg,end)区间内的所有元素，返回下一元素的位置
c.remove(val)	移除所有其值为val的元素
c.remove_if(op)	移除所有“造成op(elem)结果为true”的元素
c.resize(num)	将元素数量改为num（如果size()变大，多出来的新元素都需以default构造函数完成初始化）
c.resize(num,elem)	将元素数量改为num（如果size()变大，多出来的新元素都是elem的拷贝）
c.clear()	移除所有元素，将容器清空

特殊变更型操作

操作	效果
c.unique()	如果存在若干相邻而数值相同的元素，就移除重复元素，只留一个
c.unique(op)	如果存在若干相邻元素都使op()的结果为true，则移除重复元素，只留一个
c.splice(pos,c2)	将c2内所有元素转移（move）到c之内、迭代器pos之前
c.splice(pos,c2,c2pos)	将c2内c2pos所指元素转移到c内的pos所指位置（c和c2可相同）
c.splice(pos,c2,c2beg,c2end)	将c2内[c2beg,c2end)区间内元素转移到c内的pos之前（c和c2可相同）
c.sort()	以operator <为准则对所有元素排序
c.sort(op)	以op()为准则对所有元素排序
c.merge(c2)	假设c和c2容器都包含已排序（sorted）元素，将c2的全部元素转移到c，并保证合并后的list在op()准则下仍为已排序
c.merge(c2,op)	假设c和c2容器都包含op()准则下的已排序（sorted）元素，将c2的全部元素转移到c，并保证合并后的list仍为已排序
c.erverse()	将所有元素反序（reserve the order）