STL常用算法

非修改性序列操作（12个）

循环

for_each()

对序列中的每个元素执行某操作

查找

find()

在序列中找出某个值的第一次出现的位置

find_if()

在序列中找出符合某谓词的第一个元素

find_end()

在序列中找出一子序列的最后一次出现的位置

find_first_of()

在序列中找出第一次出现指定值集中之值的位置

adjacent_find()

在序列中找出相邻的一对值

计数

count()

在序列中统计某个值出现的次数

count_if()

在序列中统计与某谓词匹配的次数

比较

mismatch()

找出两个序列相异的第一个元素

equal()

两个序列中的对应元素都相同时为真

搜索

search()

在序列中找出一子序列的第一次出现的位置

search_n()

在序列中找出一值的连续n次出现的位置

 

 

修改性序列操作（27个）

复制

copy()

从序列的第一个元素起进行复制

copy_backward()

从序列的最后一个元素起进行复制

交换

swap()

交换两个元素

swap_ranges()

交换指定范围的元素

iter_swap()

交换由迭代器所指的两个元素

变换

transform()

将某操作应用于指定范围的每个元素

替换

replace()

用一个给定值替换一些值

replace_if()

替换满足谓词的一些元素

replace_copy()

复制序列时用一给定值替换元素

replace_copy_if()

复制序列时替换满足谓词的元素

填充

fill()

用一给定值取代所有元素

fill_n()

用一给定值取代前n个元素

生成

generate()

用一操作的结果取代所有元素

generate_n()

用一操作的结果取代前n个元素

删除

remove()

删除具有给定值的元素

remove_if()

删除满足谓词的元素

remove_copy()

复制序列时删除具有给定值的元素

remove_copy_if()

复制序列时删除满足谓词的元素

唯一

unique()

删除相邻的重复元素

unique_copy()

复制序列时删除相邻的重复元素

反转

reverse()

反转元素的次序

reverse_copy()

复制序列时反转元素的次序

环移

rotate()

循环移动元素

rotate_copy()

复制序列时循环移动元素

随机

random_shuffle()

采用均匀分布来随机移动元素

划分

partition()

将满足某谓词的元素都放到前面

stable_partition()

将满足某谓词的元素都放到前面并维持原顺序

序列排序及相关操作（27个）

排序

sort()

以很好的平均效率排序

stable_sort()

排序，并维持相同元素的原有顺序

partial_sort()

将序列的前一部分排好序

partial_sort_copy()

复制的同时将序列的前一部分排好序

第n个元素

nth_element()

将第n各元素放到它的正确位置

二分检索

lower_bound()

找到大于等于某值的第一次出现

upper_bound()

找到大于某值的第一次出现

equal_range()

找到（在不破坏顺序的前提下）可插入给定值的最大范围

binary_search()

在有序序列中确定给定元素是否存在

归并

merge()

归并两个有序序列

inplace_merge()

归并两个接续的有序序列

有序结构上的集合操作

includes()

一序列为另一序列的子序列时为真

set_union()

构造两个集合的有序并集

set_intersection()

构造两个集合的有序交集

set_difference()

构造两个集合的有序差集

set_symmetric_difference()

构造两个集合的有序对称差集（并-交）

堆操作

push_heap()

向堆中加入元素

pop_heap()

从堆中弹出元素

make_heap()

从序列构造堆

sort_heap()

给堆排序

最大和最小

min()

两个值中较小的

max()

两个值中较大的

min_element()

序列中的最小元素

max_element()

序列中的最大元素

词典比较

lexicographical_compare()

两个序列按字典序的第一个在前

排列生成器

next_permutation()

按字典序的下一个排列

prev_permutation()

按字典序的前一个排列

该篇分为十一部分，分别是：vector类的主要成员、deque类的主要成员、list类的主要成员、stack类的主要成员、queue类的主要成员、priority_queue类的组要成员、set类的主要成员、multiset类的主要成员、map类的主要成员、multimap类的主要成员、STL算法函数（一）vector类的主要成员vector<T>是可边长的向量,比较灵活☆ value_type;//对象类型T，存储在vector中 [定义地方：容器]☆ pointer;//指向T的指针 [容器]☆ reference;//T的引用 [容器]☆ const_reference;//T的常量引用 [容器]☆ size_type;//正整数类型 [容器]☆ difference_type;//整数类型 [容器]☆ iterator ;//访问vector的迭代器 [容器]☆ const_iterator;//访问vector的常量迭代器 [容器]☆ reverse_iterator;//访问vector的反向迭代器 [Reversible容器]☆ const_reverse_iterator;//访问vector的反向迭代器 [Reversible容器]☆ iterator begin();//返回vector的头指针 [容器]☆ iterator end();//返回vector的尾指针 [容器]☆ const_iterator begin() const;//返回vector的常量头指针 [容器]☆ const_iterator end() const;//返回vector的常量尾指针 [容器]☆ reverse_iterator rbegin();//返回反向vector的反向头指针 [Reversible容器]☆ reverse_iterator rend();//返回反向vector的反向尾指针 [Reversible容器]☆ const reverse_iterator rbegin() const;//返回反向vector的反向常量头指针 [Reversible容器]☆ const_reverse_iterator rend() const();//返回反向vector的反向常量尾指针 [Reversible容器]☆ size_type size() const;//返回vector的元素数量 [容器]☆ size_type max_size() const;// 返回最大可允许的vector元素数量值 [容器]☆size_type capacity() const;//返回当前所能容纳的最多元素个数 [vector]☆bool empty() const;//判断vector是否为空 [容器]☆reference operator[](size_type n); //返回第n个元素 [Random Access容器]☆const_reerence operator[](size_type n)const; //返回第n个元素 [Random Access容器]☆vector();//创建一个空vector [容器]☆vector(size_type n);//创建一个vector，元素数量为n [Sequence]☆vector(size_type n, const T& t);//创建一个vector，元素数量为n，大小都为t[Sequence]☆vector(const vector &);//拷贝构造函数 [容器]☆template<class InputIterator>vector(InputIterator, InputIterator); [Sequence]//采用拷贝的方法创建一个vector，指定了范围☆~vector();// vector的析构函数 [容器]☆vector& operator=(const vector&);//=运算符重载 [容器]☆void reserve(size_t n);//为vector预先分配n个元素 [vector]☆reference front();// 返回第一个元素 [Sequence]☆const_reference front() const;//返回第一个元素 [Sequence]☆reference back();//返回最后一个元素 [Back Insertion Sequence]☆const_reference back() const;//返回最后一个元素 [Back Insertion Sequence]☆void push_back(const T&);//在vector尾部插入一个元素 [Back Insertion Sequence]☆void pop_back();//删除最后一个元素 [Back Insertion Sequence]☆void swap(vector&);//交换两个vector的内容 [容器]☆iterator insert(iterator pos, const T& x);//在pos前出入x [Sequence]☆template<class InputIterator>void insert(iterator pos, InputIteratorf, InputIterator I);//在位置pos位置前插入范围为[fisrt, last]的元素 [Sequence]☆void insert(iterator pos, size_type n, const T& x);//在位置pos前出入n个x [Sequence]☆iterator erase(iterator pos);//删除在位置pos的元素 [Sequence]☆iterator erase(iterator first, iterator last);//删除在[first, last]之间的元素 [Sequence]☆void clear();//删除所有的元素 [Sequence]☆void resize(size_type n, t = T());//插入或删除使元素个数为n插入的值为t[Sequence]☆bool operator==(const vector&, const vector&);//重载==运算符 [Forward容器]☆bool operator<(const vector&, const vector&);//小于逻辑运算符 [Forward容器]vector类的私有成员：☆size_type capacity() const;//返回当前所能容纳的最多元素个数，其值不小于size（）☆void reserve(size_type n);//如果n小于或等于capacity()，本函数没有作用。否则，它申请分配内存如果申请成功，capacity()值应>=n:如果申请失败，capacity()不变（二）deque类的主要成员deque<T> 是一种双端队列容器，完成了标准的C++数据结构中队列的所有功能☆ value_type;//对象类型T，存储在deque中 [定义地方：容器]☆ pointer;//指向T的指针 [容器]☆ reference;//T的引用 [容器]☆ const_reference;//T的常量引用 [容器]☆ size_type;//正整数类型 [容器]☆ difference_type;//整数类型 [容器]☆ iterator ;//访问deque的迭代器 [容器]☆ const_iterator;//访问deque的常量迭代器 [容器]☆ reverse_iterator;//访问deque的反向迭代器 [Reversible容器]☆ const_reverse_iterator;//访问deque的反向迭代器 [Reversible容器]☆ iterator begin();//返回deque的头指针 [容器]☆ iterator end();//返回deque的尾指针 [容器]☆ const_iterator begin() const;//返回deque的常量头指针 [容器]☆ const_iterator end() const;//返回deque的常量尾指针 [容器]☆ reverse_iterator rbegin();//返回反向deque的反向头指针 [Reversible容器]☆ reverse_iterator rend();//返回反向deque的反向尾指针 [Reversible容器]☆ size_type size() const;//返回deque的元素数量 [容器]☆ size_type max_size() const;// 返回最大可允许的deque元素数量值 [容器]☆bool empty() const;//判断deque是否为空 [容器]☆reference operator[](size_type n); //返回第n个元素 [Random Access容器]☆const_reerence operator[](size_type n)const; //返回第n个元素[Random Access容器]☆deque();//创建一个空deque [容器]☆deque(size_type n);//创建一个deque，元素数量为n [Sequence]☆deque(size_type n, const T& t);//创建一个deque，元素数量为n，大小都为t[Sequence]☆deque(const deque &);//拷贝构造函数 [容器]☆template<class InputIterator>deque(InputIterator, InputIterator); [Sequence]//采用拷贝的方法创建一个deque，指定了范围☆~deque();// deque的析构函数 [容器]☆deque& operator=(const deque&);//=运算符重载 [容器]☆reference front();// 返回第一个元素 [Sequence]☆const_reference front() const;//返回第一个元素 [Sequence]☆reference back();//返回最后一个元素 [Back Insertion Sequence]☆const_reference back() const;//返回最后一个元素 [Back Insertion Sequence]☆void push_back(const T&);//在deque尾部插入一个元素 [Back Insertion Sequence]☆void pop_back();//删除最后一个元素 [Back Insertion Sequence]☆void swap(deque&);//交换两个deque的内容 [容器]☆iterator insert(iterator pos, const T& x);//在pos前出入x [Sequence]☆template<class InputIterator>void insert(iterator pos, InputIteratorf, InputIterator I);//在位置pos位置前插入范围为[fisrt, last]的元素 [Sequence]☆void insert(iterator pos, size_type n, const T& x);//在位置pos前出入n个x [Sequence]☆iterator erase(iterator pos);//删除在位置pos的元素 [Sequence]☆iterator erase(iterator first, iterator last);//删除在[first, last]之间的元素 [Sequence]☆void clear();//删除所有的元素 [Sequence]☆void resize(size_type n, t = T());//插入或删除使元素个数为n插入的值为t [Sequence]☆bool operator==(const deque&, const deque&);//重载==运算符 [Forward容器]☆ bool operator<(const deque&, const deque&);//小于逻辑运算符 [Forward容器]所有的deque成员都在其祖先中定义，deque自身没有定义任何新的变量或函数，除了上面的成员之后还可以查看随机接入容器（random access 容器），前向插入序（Front insertion sequence）和反向插入序列(Back insertion sequence)中定义的新变量。（三）list类的主要成员list<T>是一个双向链表容器，完成了标准C++数据结构中链表的所有功能☆ value_type;//对象类型T，存储在list中 [定义地方：容器]☆ pointer;//指向T的指针 [容器]☆ reference;//T的引用 [容器]☆ const_reference;//T的常量引用 [容器]☆ size_type;//正整数类型 [容器]☆ difference_type;//整数类型 [容器]☆ iterator ;//访问list的迭代器 [容器]☆ const_iterator;//访问list的常量迭代器 [容器]☆ reverse_iterator;//访问list的反向迭代器 [Reversible容器]☆ const_reverse_iterator;//访问list的反向迭代器 [Reversible容器]☆ iterator begin();//返回list的头指针 [容器]☆ iterator end();//返回list的尾指针 [容器]☆ const_iterator begin() const;//返回list的常量头指针 [容器]☆ const_iterator end() const;//返回list的常量尾指针 [容器]☆ reverse_iterator rbegin();//返回反向list的反向头指针 [Reversible容器]☆ reverse_iterator rend();//返回反向list的反向尾指针 [Reversible容器]☆ size_type size() const;//返回list的元素数量 [容器]☆ size_type max_size() const;// 返回最大可允许的list元素数量值 [容器]☆ bool empty() const;//判断list是否为空 [容器]☆ reference operator[](size_type n); //返回第n个元素 [Random Access容器]☆ const_reerence operator[](size_type n)const; //返回第n个元素[Random Access容器]☆ list();//创建一个空list [容器]☆ list(size_type n);//创建一个list，元素数量为n [Sequence]☆ list(size_type n, const T& t);//创建一个list，元素数量为n，大小都为t [Sequence]☆ list(const list &);//拷贝构造函数 [容器]☆ template<class InputIterator>list(InputIterator, InputIterator); [Sequence]//采用拷贝的方法创建一个list，指定了范围☆ ~list();// list的析构函数 [容器]☆ list& operator=(const list&);//=运算符重载 [容器]☆ reference front();// 返回第一个元素 [Sequence]☆ const_reference front() const;//返回第一个元素 [Sequence]☆ reference back();//返回最后一个元素 [Back Insertion Sequence]☆ const_reference back() const;//返回最后一个元素 [Back Insertion Sequence]☆ void push_back(const T&);//在list尾部插入一个元素 [Back Insertion Sequence]☆ void pop_back();//删除最后一个元素 [Back Insertion Sequence]☆ void swap(list&);//交换两个list的内容 [容器]☆ iterator insert(iterator pos, const T& x);//在pos前出入x [Sequence]☆ template<class InputIterator>void insert(iterator pos, InputIteratorf, InputIterator I);//在位置pos位置前插入范围为[fisrt, last]的元素 [Sequence]☆ void insert(iterator pos, size_type n, const T& x);//在位置pos前出入n个x[Sequence]☆ iterator erase(iterator pos);//删除在位置pos的元素 [Sequence]☆ iterator erase(iterator first, iterator last);//删除在[first, last]之间的元素 [Sequence]☆ void clear();//删除所有的元素 [Sequence]☆ void resize(size_type n, t = T());//插入或删除使元素个数为n插入的值为t[Sequence]☆ bool operator==(const list&, const list&);//重载==运算符 [Forward容器]☆ bool operator<(const list&, const list&);//小于逻辑运算符 [Forward容器]list类的私有变量：☆ void splice(iterator position, list<T, Alloc>&x);//把list对象x和当前的list对象*this链接起来，链接的起始位置由position指定，即在 position前插入一个list对象x☆ void splice(iterator position, list<T,Alloc>&x, iterator i);//把list对象x和当前的list对象*this链接起来，链接的位置由position指定，即在position前插入一个list对象 x，另外，把由迭代器i指定的元素插入到当前链表中。☆ void splice(iterator position, list<T,Alloc>&x, iterator f, iterator l);//与上面的差异是，把由从迭代器f指定的起始元素到由迭代器l指定的结尾元素插入当前链表中。☆ void remove(const T& val);//从链表中删除所有值为val的元素☆ template<class Predicate>void remove_if(Predicate p);//删除链表中判断p为真的元素☆ void unique();//删除所有重复的元素以建立一个具有唯一元素值的链表☆ template<class Binary Predicate>void unique(BinaryPredicate p);//根据指定的条件，删除所有重复的元素以建立具有唯一元素值的链表☆ void merge(list<T, Alloc>& x);//把当前的链表*this和x合并，合并后x为空，把x中的元素插入到了当前链表中，不允许两个链表相同☆ template<class BinaryPredicate> void merge(list<T, Alloc>& x, BinaryPredicate Comp);//根据给顶的条件把当前链表*this和x合并，合并后x为空，把x中的元素插入到了当前链表中，不允许两个链表相同☆ void reverse();//反转链表中的元素顺序☆ void sort();//根据默认的条件对链表进行排序☆ template<class BinaryPredicate> void sort(BinaryPredicate comp);//根据给定条件进行排序（四）stack类的主要成员stack <T>是一种栈容器，完成了标准C++数据结构中栈的所有功能。☆ stack();//默认的构造函数，生成一个空的堆栈☆ stack(const stack&);//拷贝构造函数☆ stack& operator=(const stack &);//赋值运算符重载stack 的私有成员：☆ value_type;//stack中存放的对象类型，它和stack中的T类型相同☆ size_type;//正整数类型，它和Sequence::size_type类型一样☆ bool empty()const;//判断堆栈是否为空，如果空返回true，否则返回false。☆ size_type size() const;//返回堆栈中的元素个数☆ value_type& top();//返回堆栈顶部的引用，这是一个可变化的值。堆栈非空情况下调用。☆ const value_type& top() const;//返回堆栈顶部的参考值。☆ void push(const value_type& x);//把元素x插入到堆栈的顶部，这时堆栈的长度加1。☆ void pop();//删除堆栈顶部的值，前提是堆栈非空，删除操作成功后，堆栈长度减1。☆ bool operator==(const stack&, const stack&);//比较两个堆栈是否相等☆ bool operator<(const stack&, const stack&);//比较两个堆栈是否第一个堆栈小于第二个。（五）queue类的主要成员queue<T>是一种队列容器，完成了标准C++数据结构中队列的所有功能。☆ queue();//默认的构造函数，生成一个空的堆栈☆ queue(const queue &);//拷贝构造函数☆ queue & operator=(const queue&);//赋值运算符重载queue 的私有成员：☆ value_type;//queue中存放的对象类型，它和queue中的T类型相同☆ size_type;//正整数类型，他和Sequence::size_type类型一样☆ bool empty() const;//判断队列是否为空，空则返回true，否则返回false☆ size_type size() const;//返回队列中的元素个数☆ value_type& back();//返回队列中最后一个的值☆ const value_type& back() const;//返回队列中最后一个值，该值不可变☆ value_type& front();//返回第一个值的引用，本函数的前提是队列非空☆ const value_type& front() const;//返回队列中的第一个值，改值不可变☆ void push(const value_type& x);//把元素x插入到队列的尾部，队列长度加1☆ void pop();//删除队列的第一个值，前提条件是队列非空，删除后队列长度减1☆ bool operator==(const queue&, const queue&);//比较两个队列是否相等☆ bool operator<(const queue&, const queue&);//比较两个队列是否第一个队列小于第二个。（六）priority_queue的主要成员priority_queue<T>是一种按值排序的队列容器☆priority_queue();//默认构造函数，生成一个空的排序队列☆priority_queue(const queue&);//拷贝构造函数☆priority_queue& operator=(const priority_queue &);//赋值运算符重载priority_queue 的私有成员：☆value_type;//priority_queue中存放的对象类型，它和priority_queue中的T类型相同☆priority_queue(const Compare& comp);//构造生成一个空的priority_queue对象，使用comp作为priority_queue的comparison☆priority_queue(const value_type* first, const value_type* last);//带有两个参数的构造 函数，使用默认的Comparison作为第三个参数☆size_type;//正整数类型，和Sequence::size_type类型一样。☆bool empty() const;//判断优先级队列是否为空，为空返回true，否则返回false☆size_type size() const;//返回优先级队列中的元素个数☆const value_type& top() const();//返回优先级队列中第一个元素的参考值。☆void push(const value_type& x);//把元素x插入到优先级队列的尾部，队列的长度加1☆void pop();//删除优先级队列的第一个值，前提是队列非空，删除后队列长度减1（七）set类的主要成员set<T>是一种集合容器。☆iterator begin(); //指向set的头指针☆const_iterator begin() const;//返回set的常量头指针☆void clear();//删除所有元素☆size_type count(const key_type& x)const; //返回键为x的元素的个数☆bool empty() const; //返回是否为空☆iterator end();//指向set的尾指针☆const_iterator end() const();//返回set的常量尾指针☆void erase(iterator position);//删除在位置position的元素☆size_type erase(const key_type& x);//删除索引为x的元素☆void erase(iterator first, iterator last);//删除在[first，last]间的元素☆pair<iterator, iterator>equal_range(const key_type& x)const;//返回一个迭代器对(指向键不小于x的第一个元素的迭代器，指向键大于x的第一个元素的迭代器)☆iterator find(const key_type& x)const;//返回索引为x的元素的指针☆allocator_type get_allocator() const;//返回构造函数的一个拷贝☆pair<iterator,bool>insert(const value_type& x);//返回<指向元素x的迭代器，是否插入成功>☆template<class InputIterator>void insert(InputIterator first,InputIterator last);//插入值在[first,last]间的一个序列。☆interator lower_bound(const key_type& x)const; //返指向键不小于x的第一个元素的迭代器☆size_type max_size()const;//返回该set可以控制的最大长度☆reverse_iterator rbegin();//返回反向set的反向头指针☆const_reverse_iterator rbegin() const;//返回反向set的反向常量头指针☆reverse_iterator rend();//返回反响set的反向尾指针☆ void resize(size_type Sz, T C=T());//插入或删除使元素的个数为n，插入的元素为C☆const_reverse_iterator rend() const;//返回反向set的反向尾指针☆explicit set(const Compare& comp = Compare(), const Allocator = Allocator());☆template<class InputIterator>set(InputIterator first, InputIterator last, const Compare& Comp = Compare(), const Allocator& X = Allocator());//构造函数类型，如set<int>::allocator_type s1_Alloc;s1_Alloc = s1.get_allocator();set <int> s2(s1.begin(), s1.end(), less<int>, s1_alloc);☆set(const set<Key, Compare,Allocator>& X); ☆~set();//析构函数☆size_type size() const;//返回set的大小☆void swap(set& X);//与setX交换内容☆iterator upper_bound(const key_type& x)const;//返回指向键大于x的第一个元素的迭代器（八）multiset的主要函数multiset <T>是一种允许出现重复元素的集合容器☆以下只列函数名（以上面那些基本一样，可根据上面的函数获取更详细信息）begin, clear, count, empty, end, equal_range, erase, find ,get_allocator, insert, key_comp,lower_bound, max_size, rbegin, rend, size, swap, upper_bound, value_compoperator!=, operator==, operator<, operator<=, operator>, operator>=,swap（九）map的主要函数map <key, val > 是一种关联数组容器begin, clear, count, empty, end, equal_range, erase, find, get_alloctor, insert, key_comp, lower_bound, max_size, operator[], rbegin, rend, size,swap,upper_bound, value_compoperator!=, operator==, operator<, operator<=, operator>, operator>=, swap（十）multimap的主要函数multimap <T>是一种允许出现重复key值的关联数组容器begin, clear, count, empty, end, equal_range, erase, find, get_alloctor, insert, key_comp, lower_bound, max_size, rbegin, rend, size, swap, upper_bound, value_comp（十一）STL的算法函数☆ template<class InIt, class T>T accumulate(InIt first, InIt last, T val);//元素累加☆ template<class InIt, class OutIt>OutIt adjacent_difference(InIt first, InIt last,OutIt result); //相邻元素的差额========================由于量太多，以下只列函数名=========================☆ adjacent_find();//搜寻相邻的重复元素☆ binary_search();//二元搜寻☆ copy();//复制☆ copy_backward();//逆向复制☆ count();//计数☆ count_if();//在特定的条件下计数☆ equal();//判断相等与否☆ equal_range();//判断相等与否（返回一个上下限区间的范围）☆ fill();//改填元素的值☆ fill_n();//改填元素的值，n次☆ find();//搜寻☆ find_if();//在特定的条件下搜寻☆ find_end();//搜寻某个子序列的最后一次出现的地点☆ find_first_of();//搜寻某些元素的首次出现地点☆ for_each();//对范围内的每一个元素施行操作☆ generate();//以指定动作的运算结果填充特定范围内的元素☆ generate_n();//以指定动作的运算结果填充n个元素的内容☆ includes();//包含于☆ inner_product();//内积☆ inplace_merge();//合并并取代（覆写）☆ iter_swap();//元素互换☆ lexicographical_compare();//以字典排列方式做比较☆ lower_bound();//下限☆ max();//最大值☆ max_element();//最大值所在位置☆ min();//最小值☆ min_element();//最小值所在位置☆ merge();//合并两个序列☆ mismatch();//找出不吻合点☆ next_permutation();//获得下一个排列组合☆ nth_element();//重新安排序列中第n个元素的左右两端☆ parital_soft();//局部排序☆ partial_sort_copy();//局部排序并复制到它处☆ partial_sum();//局部总和☆ partition();//切割☆ prev_permutation();//获得前一个排列组合☆ random_shuffle();//随机重排☆ remove();//移除某种元素（但不删除）☆ remove_copy();//移除某种元素并将结果复制到另一个container☆ remove_if();//有条件地移除某种元素☆ remove_copy_if();//有条件地移除某种元素并将结果复制到另一个container☆ replace();//取代某种元素☆ replace_copy();//取代某种元素，并将结果复制到另一个container☆ replace_copy_if();//有条件地取代，并将结果复制到另一个container☆ reverse();//颠倒元素次序☆ reverse_copy();//颠倒元素次序并将结果复制到另一个container☆ rotate();//旋转☆ rotate_copy();//旋转并将结果复制到另一个container☆ search();//搜寻某个子序列☆ search_n();//搜寻[连续发生n次]的子序列☆ set_difference();//差集☆ set_intersection();//交集☆ set_symmetric_difference();//对称差集☆ set_union();//联集☆ sort();//排序☆ stable_partition();//切割并保持元素相对次序☆ stable_sort();//排序并保持等值元素的相对次序☆ swap();//置换（对调）☆ swap_range();//置换（指定范围）☆ transform();//以两个序列为基础，交互作用产生第三个序列☆ unique();//将重复的元素折叠缩编，使成唯一☆ unique_copy();//将重复的元素折叠缩编，使成唯一，并复制到他处☆ upper_bound();//上限☆ make_heap();//制造一个heap☆ pop_heap();//从heap内取出一个元素☆ push_heap();//将一个元素推进heap内☆ sort_heap();//对heap排序</p></div>