前向链表--Forward List

STL中，Forward list（class forward_list<>的一个实例）使用一个singly linked list管理元素，不支持随机访问。相较于双向链表，Forward list只提供前向迭代器，且没有指向最末元素的指针。

单向链表–Singly Linked List

Class IntSLLNode{
	public:
		IntSLLNode(){
			next = 0;
		}
		IntSLLNode(int i, IntSLLNode *in = 0){
			info = i; next = in;
		}

	int info;
	IntSLLNode *next;
};

Class IntSLList{
	public:
		IntSLList(){
			head = tail = 0;
		}
		~IntSLList();
		Int isEmpty(){
			return head == 0;
		}
		void addToHead(int);	// O(1)
		void addToTail(int);	// O(1)
		int deleteFromHead();	// O(1)
		int deleteFromTail();	// O(n)
		void deleteNode(int);	// O(n)
		bool isInList(int) const;	// O(n)
	private:
		IntSLLNode *head, *tail;
};

使用forward list时必须先包含头文件<forward_list>：

include <forward_list>

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

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

初始化

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

非变更型操作

操作	效果
c.empty()	返回是否容器为空（相当于size()==0但也许较快）
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.begin()	返回一个bidirectional iterator指向第一个元素
c.end()	返回一个bidirectional iterator指向最末元素的下一位置
c.cbegin()	返回一个const bidirectional iterator指向第一个元素
c.cend()	返回一个const bidirectional iterator指向最末元素的下一位置
c.before_begin()	返回一个forward iterator指向第一元素的前一位置
c.cbefore_begin()	返回一个const forward iterator指向第一元素的前一位置

插入与移除

操作	效果
c.push_front(elem)	在头部插入elem的一个拷贝
c.pop_front()	移除第一元素，但是不返回它
c.insert_after(pos,elem)	安插一个elem拷贝于iterator位置pos之后，并返回新元素的位置
c.insert_after(pos,n,elem)	安插n个elem拷贝于iterator位置pos之后，并返回第一个新元素的位置（或返回pos–如果没有新元素的话）
c.insert_after(pos,beg,end)	将[beg,end)区间内所有元素复制一份，安插于iterator位置pos之后，并返回第一个新元素的位置（或返回pos–如果没有新元素的话）
c.insert_after(pos,initlist)	将初值列initlist的所有元素复制一份，安插于iterator位置pos之后，并返回第一个新元素的位置（或返回pos–如果没有新元素的话
c.emplace_after(pos,args…)	在iterator位置pos之后插入一个以args为初值的元素，并返回新元素的位置
c.emplace_front(args…)	插入一个以args为初值的元素于起点，不返回任何东西
c.erase_after(pos)	移除iterator位置pos后的元素，不返回任何东西
c.erase_after(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_after(pos,c2)	将c2内所有元素转移（move）到c之内、迭代器pos之右（后）
c.splice_after(pos,c2,c2pos)	将c2内c2pos所指元素转移到c内的pos所指位置（c和c2可以是同一容器）
c.splice_after(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的全部元素转移（move）到c，并保证合并后的list仍为已排序（sorted）
c.merge(c2,op)	假设c和c2容器都包含op()准则下的已排序（sorted）元素，将c2的全部元素转移（move）到c，并保证合并后的所有元素在op()准则下仍为已排序（sorted）
c.erverse()	将所有元素反序（reserve the order）