现在的位置: 首页 > 综合 > 正文

STL常用算法

2018年03月17日 ⁄ 综合 ⁄ 共 14115字 ⁄ 字号 评论关闭

该篇分为十一部分,分别是:

1. vector类的主要成员、

2. deque类的主要成员、

3. list类的主要成员、
4. stack类的主要成员、

5. queue类的主要成员、

6. priority_queue类的组要成员、

7. set类的主要成员、

8. multiset类的主要成员、

9. map类的主要成员、

10. multimap类的主要成员、

11. STL算法函数

 

(一)vector类的主要成员
vector是可边长的向量,比较灵活
☆ 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 &);//拷贝构造函数 [容器]
☆templatevector(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]
☆templatevoid 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是一种双端队列容器,完成了标准的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 &);//拷贝构造函数 [容器]
☆templatedeque(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]
☆templatevoid 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是一个双向链表容器,完成了标准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 &);//拷贝构造函数 [容器]
☆ templatelist(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]
☆ templatevoid 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&x);//把list对象x和当前的list对象*this链接起来,链接的起始位置由position指定,即在
position前插入一个list对象x
☆ void splice(iterator position, list&x, iterator
i);//把list对象x和当前的list对象*this链接起来,链接的位置由position指定,即在position前插入一个list对象
x,另外,把由迭代器i指定的元素插入到当前链表中。
☆ void splice(iterator position, list&x, iterator f, iterator
l);//与上面的差异是,把由从迭代器f指定的起始元素到由迭代器l指定的结尾元素插入当前链表中。
☆ void remove(const T& val);//从链表中删除所有值为val的元素
☆ templatevoid remove_if(Predicate p);//删除链表中判断p为真的元素
☆ void unique();//删除所有重复的元素以建立一个具有唯一元素值的链表
☆ templatevoid unique(BinaryPredicate
p);//根据指定的条件,删除所有重复的元素以建立具有唯一元素值的链表
☆ void merge(list&
x);//把当前的链表*this和x合并,合并后x为空,把x中的元素插入到了当前链表中,不允许两个链表相同
☆ templatevoid merge(list& x, BinaryPredicate
Comp);//根据给顶的条件把当前链表*this和x合并,合并后x为空,把x中的元素插入到了当前链表中,不允许两个链表相同

☆ void reverse();//反转链表中的元素顺序
☆ void sort();//根据默认的条件对链表进行排序
☆ templatevoid sort(BinaryPredicate comp);//根据给定条件进行排序

 

(四)stack类的主要成员
stack 是一种栈容器,完成了标准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是一种队列容器,完成了标准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是一种按值排序的队列容器
☆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是一种集合容器。
☆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]间的元素
☆pairequal_range(const key_type&
x)const;//返回一个迭代器对(指向键不小于x的第一个元素的迭代器,指向键大于x的第一个元素的迭代器)
☆iterator find(const key_type& x)const;//返回索引为x的元素的指针
☆allocator_type get_allocator() const;//返回构造函数的一个拷贝
☆pairinsert(const value_type&
x);//返回<指向元素x的迭代器,是否插入成功>
☆templatevoid 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());
☆templateset(InputIterator first, InputIterator last, const
Compare& Comp = Compare(), const Allocator& X =
Allocator());//构造函数类型,如
set::allocator_type s1_Alloc;
s1_Alloc = s1.get_allocator();
set s2(s1.begin(), s1.end(), less, s1_alloc);

☆set(const set& X);
☆~set();//析构函数
☆size_type size() const;//返回set的大小
☆void swap(set& X);//与setX交换内容
☆iterator upper_bound(const key_type&
x)const;//返回指向键大于x的第一个元素的迭代器

 

(八)multiset的主要函数
multiset 是一种允许出现重复元素的集合容器
☆以下只列函数名(以上面那些基本一样,可根据上面的函数获取更详细信息)
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_comp
operator!=, operator==, operator<, operator<=, operator>,
operator>=,swap

 

(九)map的主要函数
map 是一种关联数组容器
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_comp
operator!=, operator==, operator<, operator<=, operator>,
operator>=, swap

 

(十)multimap的主要函数
multimap 是一种允许出现重复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的算法函数
☆ templateT accumulate(InIt first, InIt last, T val);//元素累加
☆ templateOutIt 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排序

抱歉!评论已关闭.