STL 笔记（五） 算法 algorithm

转载：http://blog.csdn.net/thisinnocence/article/details/39941603

在 STL 中，算法是一系列的函数模版。STL 提供了大概 70 个算法，由头文件 <algorithm>、<numeric>、<functional>组成。

• 头文件 <algorithm>   是最大的一个，里面常用到的功能有：查找、排序、修改、移除、交换、合并等；
• 头文件 <numeric>     较小，主要包括相关数学运算的函数模版，以及加法和乘法在序列上的一些操作；
• 头文件 <functional>  中则定义了一些类模版，来声明函数对象；

算法的分类：

• 算法按其实现的功能可分为 8 类：查找、排序、数值计算、比较、集合、容器管理、统计、 堆操作；
• 算法按对容器的影响可分为 4 类：非修正、修正、排序、数值计算；

非修正算法

非修正即不对容器中元素做修改，是只读操作。如：find()、count()、equal()、for_each()、search()等。具体如下：

[python] view plaincopy

1. adjacent_find     #查找相同的相邻元素 返回第一个元素的迭代器  
2. find              #查找  
3. find_first_of  
4. find_end  
5. find_last_of  
6. count             #统计相同元素的个数  
7. count_if  
8. mismatch          #返回 pair<第一个序列的迭代器，第二个序列的迭代器> 表明第一处不相符合的位置  
9. equal             #比较容器中的元素是否相同  
10. for_each          #常用，遍历序列并对序列中每个元素采用仿函数中定义的操作  
11. search            #返回迭代器，第一次出现序列二或者某元素的位置  
12. search_n          #前n次连续出现某元素或者符合条件的第一个位置  

修正算法

修正算法即对容器中元素做修改，需要写操作。如：copy()、remove()、reverse()、swap()、unique()等。具体如下：

[python] view plaincopy

1. copy                #复制元素到目的容器  
2. copy_backward       #从后往前复制  
3. fill                #用某元素填充容器  
4. fill_n  
5. generate            #把仿函数产生的结果依次复制到容器中  
6. generate_n  
7. partition           #以仿函数为标准，把容器分成前后两部分，前半部分是能使仿函数返回真的元素，后半返回假  
8. stable_partition  
9. random_shuffle      #对容器中的元素进行随机排列  
10. remove              #删除某一范围内的元素，注意：移除的元素被放到容器末尾，还是可以用迭代器遍历到，函数返回移除后容器的末尾  
11. remove_if  
12. erase               #擦除区间内所有的元素  
13. replace             #在规定区间内把某值换成新值  
14. replace_if  
15. replace_copy        #把区间内元素复制到目的地并且把其中某些元素替换成新值  
16. replace_copy_if  
17. rotate              #把 middle-end 的元素放到 first 的位置上  
18. rotate_copy  
19. swap                #元素的交换  
20. swap_ranges  
21. transform           #把元素按照仿函数中内容转换  
22. unique              #保证相邻元素间没有相同的，可以加仿函数做为判断依据，返回最后一个位置的迭代器  
23. unique_copy  

排序算法

排序需要移动元素，所以需要用到随机访问迭代器 RandomAccessIterator，并且指定 [begin,end) 这个前闭后开区间，且可自己定义比较函数做参数传入。

常见容器的排序

• vector 和 deque，还有数组，支持随机存取，可以用 algorithm 中的排序；
• list 容器是双向链表，不支持随机访问迭代器，内置了一种稳定排序方法，用的是自底向上的归并排序；
• map 和 set 底层是红黑树，本身就是有序存储；

常用的排序函数

[python] view plaincopy

1. sort                    #对给定区间所有元素进行排序，用的是快排  
2. stable_sort             #稳定排序，保证值相等的元素排序后相对位置不变，用归并排序实现  
3. partial_sort            #部分排序，保证前n个值有序并且后面的值不在前n个值的范围内，但后面的值不保证有序，堆排序实现  
4. partial_sort_copy       #对给定区间复制并排序  
5. nth_element             #把第n个元素放到第n个位置上去，比它大的都在后，比它小的都在前，但各自都不保证有序  
6. is_sorted               #判断一个区间是否已经排好序  
7. partition               #使得符合某个条件的元素放在前面  
8. stable_partition        #相对稳定的使得符合某个条件的元素放在前面  

常用的比较函数

[python] view plaincopy

1. less              #小于（缺省比较函数）  
2. greater           #大于  
3. equal_to          #等于  
4. less_equal        #小于等于  
5. greater_equal     #大于等于  

自定义比较大小

使用时不能直接写入仿函数的名字，而是要写其重载的() 函数，如 less<int>()。下面是 stl 中的 less 的部分源码：

[cpp] view plaincopy

1. template <class _Tp>  
2. struct less : public binary_function<_Tp,_Tp,bool>  
3. {  
4.   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }  
5. };  

对于基本数据类型和 string 可以使用 stl 中现成的函数模版，对于自己定义的类，可以通过自己写比较函数或重载 < 操作符来实现。其中，重载 < 运算符相当于间接的用到了内置的 less  。

小例子

[cpp] view plaincopy

1. #include <iostream>  
2. #include <vector>  
3. #include <algorithm>  
4. using namespace std;  
5.   
6. class Test {  
7. public:  
8.     Test(int a):a(a){};  
9.     int a;  
10.     bool operator <(const Test &k) const {  
11.         return a < k.a;  
12.     }  
13. };  
14.   
15. int main(){  
16.     vector<Test> a;  
17.     a.push_back(Test(2));  
18.     a.push_back(Test(3));  
19.     a.push_back(Test(1));  
20.     vector<Test>::iterator iter;  
21.     sort(a.begin(), a.end());  
22.     for(iter = a.begin(); iter != a.end(); ++iter){  
23.         cout<< iter->a <<" ";  
24.     }  // 输出排序后：1 2 3  
25. }  

数值计算

数值计算函数

数值计算算法主要针对容器中元素的计算，如 accumulate()、inner_product()、partial_sum()、adjacent_difference()和一些推广的数值算法。具体：

[python] view plaincopy

1. accumulate          #遍历求和，也可以用仿函数求其他数值  
2. inner_product       #内积，相应位置相乘再相加  
3. partial_sum         #部分元素之和，把结果放到后一容器中，后一容器的第n个元素师前一容器的前n个容器元素之和  
4. adjacent_difference #相邻元素之差，把结果放到后一容器中  

小例子

[cpp] view plaincopy

1. #include <iostream>  
2. #include <functional>  
3. #include <numeric>  
4. #include <vector>  
5. using namespace std;  
6. int main() {  
7.     int a[3] = { 2, 2, 3 };  
8.     int re = accumulate(a, a + 3, 0);  
9.     cout << re << endl;    // 7, 累加  
10.     vector<int> b;  
11.     b.push_back(2);  
12.     b.push_back(2);  
13.     b.push_back(3);  
14.     int re1 = accumulate(b.begin(), b.end(), 0, plus<int>());  
15.     cout << re1 << endl;  // 7, 累加  
16.     int re2 = accumulate(b.begin(), b.end(), 1, multiplies<int>());  
17.     cout << re2;          // 12, 累乘  
18. }  

有序容器、堆、集合

[python] view plaincopy

1. binary_search    #二分法搜索，在有序容器中提高搜索速度  
2. lower_bound      #返回第一次出现该元素的位置  
3. upper_bound      #返回最后一次出现该元素的后一位置  
4. equal_range      #返回pair<lower_bound,upper_bound>  
5. inplace_merge    #将连贯有序序列合并  
6. merge            #合并两个容器  
7. includes         #判断某区间内所有的元素是否在另一区间中  
8.   
9. #堆操作  
10. push_heap  
11. pop_heap  
12. sort_heap  
13. make_heap  
14.   
15. #集合操作  
16. set_intersection  
17. set_difference  
18. set_symmetric_difference  
19.   
20. #最值  
21. min                       #最小  
22. max                       #最大  
23. min_element               #最小位置的迭代器  
24. max_element               #最大位置的迭代器  
25. lexicograplical_compare   #范围内的字典序比较，前后序列的比较  
26. next_permutation prev_permutation   #上一个/下一个全排列  

【原文地址：http://blog.csdn.net/thisinnocence/article/details/39941603】