算法函数总结

算法函数的总结：算法函数不会改变容器内的个数，这个要注意，另外在给自定义的类用算法函数的时候，要注意细节，有些要定义好等于符号，小于符号，否则会出错

有很多函数都要注意一些细节，例如如果只指明一个区间的开始位置，则要注意越界的风险，有copy类的要注意容器的大小足够大

具体用法参考http://www.cplusplus.com/reference/algorithm/

all_of:如果所有元素都满足条件则返回true，如果有一个不满足则返回false

bVec = all_of(iVec.begin(), iVec.end(), [](int x) {return x > m; });

 

any_of：如果有一个元素满足条件，则返回true，否则返回false

bVec = any_of(iVec.begin(), iVec.end(), [](int x) {return x > m; });

 

none_of：如果所有的条件都不满足条件，则返回true，否则返回false

bVec = none_of(iVec.begin(), iVec.end(), [](int x) {return x > m; });

 

for_each:用来对容器进行某个操作，例如对容器内的元素输出

for_each(iVec.begin(), iVec.end(), [](auto x) {cout << x << " "; });

 

find：寻找容器某个区间某个元素，返回一个迭代器

it = find(iVec.begin(), iVec.end(), m);

 

find_if：寻找满足某个条件的第一个元素

it = find_if(iVec.begin(), iVec.end(), [](auto x) {return x & 1; });

 

find_if_not：寻找不满足某个条件的第一个元素

it = find_if_not(iVec.begin(), iVec.end(), [](auto x) {return x & 1;  });

 

find_end：查找子序列，返回最后一个子序列的开始元素的迭代器

it = find_end(iVec.begin(), iVec.end(), iDeque.begin(), iDeque.end());

 

find_first_of:寻找某个区间中一个元素，该元素存在于另一个区间

it = find_first_of(iVec.begin(), iVec.end(), iDeque.begin(), iDeque.end());

 

adjacent_find:寻找一个区间中相邻且相等的元素，返回第一个元素的迭代器

it = adjacent_find(iVec.begin(), iVec.end());

 

count:寻找容器中的某个元素的个数

iCount = count(iVec.begin(), iVec.end(), m);

 

count_if:寻找容器中满足某个条件的元素的个数

iCount = count_if(iVec.begin(), iVec.end(), [](int x) {return x & 1; });

 

miamatch:依次比较两个序列的元素每个元素，返回第一对不相等的元素，该函数只有三个参数，第一个，第二个代表一个序列范围，第三个代表另一个序列的起始位置，返回的是一个pair类型分别指向不相等的两个数

iVecPair = mismatch(iVec.begin(), iVec.end(), iVec2.begin());

equal:和miamatch的用法一样，返回的是一个bool

bVec = equal(iVec.begin(), iVec.end(), iVec2.begin());

 

is_permutation:判断两个序列中元素是否相等，不考虑元素的顺序

bVec = is_permutation(iVec.begin(), iVec.end(), iVec2.begin());

 

search:查找第一个子序列，返回开始位置

it = search(iVec.begin(), iVec.end(), iVec2.begin(), iVec2.end());    

 

search_n:查找连续n个等于m值；如果有排序规则，查找连续n个满足某个条件的元素位置，拉姆达表达式里的第二个参数都为m，没有任何用，只需保持类型一样即可

it = search_n(iVec.begin(), iVec.end(), n, m);

it = search_n(iVec.begin(), iVec.end(), n, m,[](int x, int y) { return !(x & 1); });

 

copy:将一个区间的元素复制到另一个区间

copy(iVec.begin(), iVec.end(), iVec2.begin());

 

copy_n: 从序列的某个地方开始，复制连续 n 个元素，到另一个序列，需要保证源序列和目标序列都有足够的元素

copy_n(iVec.begin(), m, iDeque.begin());

 

copy_if:将满足条件的元素，复制到另一个序列中

copy_if(iVec.begin(), iVec.end(), iDeque.begin(), [](auto x) {return x & 1; });

 

copy_backward:将第一个区间的元素复制到另一个区间的后面，第三参数为结束的位置

copy_backward(iVec.begin(), iVec.begin() + m, iDeque.end());

 

move:移动元素，与copy的用法差不多

move(iVec.begin(), iVec.end() - 1, iVec.begin() + 1);

 

move_backward: 将第一个区间的元素移动到另一个区间的后面，第三参数为结束的位置

move_backward(iVec.begin(), iVec.begin() + 4, iDeque.end());

 

swap:交换两个迭代器

swap(iIt1, iIt2);

 

swap_ranges:交换一段区间的值

swap_ranges(iVec.begin(), iVec.end(), iVec2.begin());

 

iter_swap:交换两个迭代器所指向的值

iter_swap(iIt1, iIt2);

 

transform:对一个区间内的元素做某种操作，然后复制到另一个区间中，原来的区间不变

transform(iVec.begin(), iVec.end(), iVec2.begin(), [](auto x) {return x * 2; });

 

 

replace:将一个区间中的某个元素替换为某个值

replace(iVec.begin(), iVec.end(), 11, 1);

 

replace_if:将一个区间中满足某个条件的元素替换为某个值

replace_if(iVec.begin(), iVec.end(), [](auto x) {return x & 1; }, 0);

 

replace_copy:将替换后的序列复制到另一个区间中，原区间的元素不变

replace_copy(iVec.begin(), iVec.end(), iVec2.begin(), 222, 999);

 

replace_copy_if: 将满足条件的元素替换，替换后的序列复制到另一个区间中，但原区间的元素不变

replace_copy_if(iVec.begin(), iVec.end(), iVec2.begin(), [](auto x) {return x & 1; }, 0);

 

fill:对某个区间用m进行填充

fill(iVec.begin(), iVec.end() - 3, m);

 

fill_n:从某个某个迭代器开始n个值填充为m

fill_n(iVec.begin(), n, m);

 

generate:按照某种规则设置区间的值

generate(iVec.begin(), iVec.end(), []() {return 5; });

 

generate_n:按照某种规则，设置从起始位置开始第n个元素的值

generate_n(iVec.begin(), n, []() {return 10; });

 

remove:删除元素，但不是真正意义上的删除，因为算法函数不能改变容器内的元素，它只是将要删除的元素用后面的函数替换，最后返回一个迭代器，这个迭代器是结束的位置，从起始位置到这个迭代器之间是删除元素都得正确区间

it = remove(iVec.begin(), iVec.end(), 55);

 

remove_if:将满足条件的元素删除，删除的意义跟上面的类似

it = remove_if(iVec.begin(), iVec.end(), [](auto x) {return x & 1; });

 

remove_copy: 删除元素，把删除后的正确的区间复制到另一个区间中，原来的区间元素并没有变

remove_copy_if: 将满足条件的元素删除，把删除后的正确的区间复制到另一个区间中，原来的区间元素并没有变

 

 

 

unique:删除一个区间中的相邻且相等的元素，删除的意义跟上面的类似

it = unique(iVec.begin(), iVec.end());

unique_copy: 删除一个区间中的相邻且相等的元素，将正确的区间复制到另一个区间中，原来的区间元素没有变

 

reverse:将一个区间逆序

reverse(iVec.begin(), iVec.end());

 

reverse_copy: 将一个区间逆序，逆序后的结果复制到另一个区间中

 

rotate:将一个区间旋转，将第一个参数到第二参数的范围（不包括第二个参数的值）

旋转到后面

rotate(iVec.begin(), iVec.begin() + 3, iVec.end());

 

rotate_copy:将旋转后的区间复制到另一个区间中，原来区间的元素没有变

 

random_shuffle: 将一个序列按照自定义的规则进行随机重排，它的随机规则是从序列的第二元素开始到最后，当前元素与第n+1个元素交换，第三个参数的规则不能返回二以及二以上的数

random_shuffle(iVec.begin(), iVec.end(), [](auto x) {return n; });

 

shuffle:将一个序列进行随机重排

shuffle(iVec.begin(), iVec.end(), default_random_engine(time(NULL)));

 

is_partitioned:判断一个区间是否按照某种条件排序好了

cout << (is_partitioned(iVec.begin(), iVec.end(), [](auto x) {return x & 1; })

                   ? "is_partitioned" : "not_is_partitioned") << endl;

 

partition:将一个序列按条件进行分类，满足条件的放在前面，不满足条件的放在后面

partition(iVec.begin(), iVec.end(), [](auto x) {return x & 1; });

 

stable_partition:稳定排序，将一个序列按条件进行分类，满足条件的放在前面，不满足条件的放在后面

stable_partition(iVec.begin(), iVec.end(), [](auto x) {return x & 1; });

 

partition_copy: 将一个序列按条件进行分类，满足条件的放在前面，不满足条件的放在后面

，将排序后的结果复制到另一个容器中，原来的序列不变

 

partition_point:找出一个序列中的分界点，左闭右开原则，返回第一部分的右迭代器

cout << "iVec的分界点为：" << *(partition_point(iVec.begin(), iVec.end(), [](auto x) {return x & 1; })) << endl;

 

sort:将一个区间进行排序，可以自定义排序规则

sort(iVec.begin(), iVec.end());

 

stable_sort: 稳定排序，将一个区间进行排序，可以自定义排序规则

 

 

partial_sort:不是部分排序的意思，是排出前面若干个元素，后面的元素就不管了

partial_sort(iVec.begin(), iVec.begin() + m, iVec.end());

 

partial_sort_copy: 排出前面若干个元素，后面的元素就不管了，然后将其复制到另一个区间，原来的区间元素没有变化

partial_sort_copy(iVec.begin(), iVec.end(), iVec2.begin(), iVec2.begin() + 5);

 

is_sorted:判断一个区间内的元素是否排序好了

cout << (is_sorted(iVec2.begin(), iVec2.end()) ? "is_sort" : "not_is_sort") << endl;

 

is_sorted_until:查找第一个不满足排序规则的元素

cout <<  *(is_sorted_until(iVec2.begin(), iVec2.end())) << endl;

 

lowed_bound:寻找大于或者等于的某个值的元素位置（如果是降序的话，寻找小于或者等于的）

it = lower_bound(ivec.begin(),ivec.end(),m);

 

upper_bound: 寻找大于的某个值的元素位置（如果是降序的话，寻找小于的）

it2 = upper_bound(ivec.begin(), ivec.end(), m);

 

equal_range:寻找某个值，返回一个pair类型，分别为lowed_bound和upper_bound，指定它的范围

itpair = equal_range(ivec.begin(),ivec.end(),m);

 

binary_search:二分法查找，序列必须满足升序排序或者是降序排序

bvec=binary_search(ivec.begin(),ivec.end(),m);

 

merge:归并排序，两个都是要有序的，并且需要目标容器大小要足够大

merge(ivec.begin(), ivec.end(), ivec2.begin(), ivec2.end(),ivec3.begin());

 

inplace_merge:在一个容器内部进行归并排序，前半部分和后半部分都必须是有序的

inplace_merge(ivec3.begin(), it, ivec3.end());

 

includes:判断一个序列是否包含另一个序列，要求两个序列都需要有序的

bvec = includes(ivec3.begin(),ivec3.end(),ivec.begin(),ivec.end());

 

set_union:获得两个序列中并集的部分存到第三个序列中

it=set_union(ivec.begin(), ivec.end(), ivec2.begin(), ivec2.end(), ivec3.begin());

 

set_intersection: 获得两个序列中交集的部分存到第三个序列中

it = set_intersection(ivec.begin(), ivec.end(), ivec2.begin(), ivec2.end(), ivec3.begin());

 

set_difference: 获得两个序列中差集的部分存到第三个序列中

it = set_difference(ivec.begin(), ivec.end(), ivec2.begin(), ivec2.end(), ivec3.begin());

 

set_symmetric_difference: 获得两个序列中对称差集的部分存到第三个序列中

 

 

push_heap:添加一个元素，并调整堆的结构，成为一个大堆或者小堆

push_heap(ivec.begin(), ivec.end(), greater<int>());

 

pop_heap:删除一个元素，并调整堆的结构，成为一个大堆或者小堆

pop_heap(ivec.begin(), ivec.end(), greater<int>());

 

make_heap: 把序列构造成堆结构

make_heap(ivec.begin(),ivec.end(),greater<int>());

 

sort_heap:堆一个区间进行堆排序

sort_heap(ivec.begin(), ivec.end(), greater<int>());

is_heap:判断一个序列是否为堆排序

bVec=is_heap(ivec.begin(),ivec.end(), greater<int>())

 

is_heap_until:找到第一个不满足堆排序的元素

由于算法函数并不会改变容器内的元素个数，所以在使用push_heap之前先用push_back添加一个元素，使用pop_heap后使用pop_back