文章目录
-
- 测试环境
- algorithm介绍
- 头文件
- 元素删除相关算法
- 元素遍历算法
- 查找算法
- 移位算法
- 比较算法
- 排序算法
- 拷贝算法
- 判断算法
- 元素填充
- 替换算法
- 其他算法
测试环境
系统：ubuntu 22.04.2 LTS 64位
gcc版本：11.3.0
编辑器：vsCode 1.76.2
algorithm介绍
- 其中封装了常用的算法
头文件
#include
void myprint(std::vector<int> &vctTest)
{
for_each(vctTest.begin(), vctTest.end(), [](int &value){std::cout << value << "\t";});
std::cout << std::endl;
}
元素删除相关算法
| 函数名 |
返回值 |
功能 |
| remove() |
指向删除后序列中最后一个元素的下一个位置 |
删除指定范围内的固定元素 |
| remove_if() |
指向删除后序列中最后一个元素的下一个位置 |
根据自定义规则删除指定范围内的元素 |
| remove_copy() |
指向目标序列中最后一个有效元素的下一个位置 |
删除指定范围内的固定元素，并将剩余元素拷贝到目标序列中 |
| remove_copy_if() |
指向目标序列中最后一个有效元素的下一个位置 |
根据自定义规则删除指定范围内的元素，并将剩余元素拷贝到目标序列中 |
| unique() |
指向删除后序列中最后一个元素的下一个位置 |
删除指定范围连续重复元素 |
| unique_copy() |
指向目标序列中最后一个有效元素的下一个位置 |
删除指定范围连续重复元素，并将剩余元素拷贝到目标序列中 |
std::vector<int> vctTest = {1,2,3,3,3,2,1};
std::remove(vctTest.begin(), vctTest.end(), 3);
std::cout << "remove():";
myprint(vctTest);
vctTest = {1,2,3,3,3,2,1};
std::remove_if(vctTest.begin(), vctTest.end(), [](int value){ return value > 2; });
std::cout << "remove_if():";
myprint(vctTest);
vctTest = {1,2,3,3,3,2,1};
std::vector<int> vctTemp;
vctTemp.resize(7);
std::remove_copy(vctTest.begin(), vctTest.end(), vctTemp.begin(), 3);
std::cout << "remove_copy():";
myprint(vctTemp);
vctTest = {1,2,3,3,3,2,1};
vctTemp.clear();
vctTemp.resize(7);
std::remove_copy_if(vctTest.begin(), vctTest.end(), vctTemp.begin(), [](int value){ return value > 2; });
std::cout << "remove_copy_if():";
myprint(vctTemp);
vctTest = {1,2,3,3,3,2,1};
std::unique(vctTest.begin(), vctTest.end());
std::cout << "unique():";
myprint(vctTest);
vctTest = {1,2,3,3,3,2,1};
vctTemp.clear();
vctTemp.resize(7);
std::unique_copy(vctTest.begin(), vctTest.end(), vctTemp.begin());
std::cout << "unique_copy():";
myprint(vctTest);
元素遍历算法
| 函数名 |
返回值 |
功能 |
| for_each() |
函数对象 |
遍历指定范围的所有元素 |
| for_each_n() |
指向遍历范围最后一个元素的下一个位置 |
遍历指定位置开始的固定数量个元素 |
| next() |
指向计算后的位置 |
从指定位置开始向后迭代指定的步数 |
| prve() |
指向计算后的位置 |
从指定位置开始向前迭代指定的步数 |
std::vector<int> vctTest = {12,3,6,90,33,2,8,56,41,1};
std::cout << "for_each():";
for_each(vctTest.begin(), vctTest.end(), [](int &value){std::cout << value << "\t";});
std::cout << std::endl;
std::cout << "for_each_n():";
auto itr = for_each_n(vctTest.begin()+3, 5, [](int &value){std::cout << value << "\t";});
std::cout << *itr << std::endl;
std::cout << "next():" << *(std::next(vctTest.begin(), 3)) << std::endl;
std::cout << "prve():" << *(std::prev(vctTest.end(), 3)) << std::endl;
查找算法
| 函数 |
返回值 |
功能 |
| find() |
指向指定元素的迭代器，未找到指向序列的末尾元素的下一个位置，即容器的end()位置 |
在指定序列范围内查找指定元素 |
| find_if() |
指向找到的符合要求的首元素位置，未找到指向序列的末尾元素的下一个位置，即容器的end()位置 |
在指定序列范围中根据自定义规则查找元素 |
| find_if_not() |
指向找到的不符合要求的首元素位置，未找到指向序列的末尾元素的下一个位置，即容器的end()位置 |
在指定序列范围内查找第一个不满足条件的元素 |
| find_first_of() |
指向首个包含在目标序列中的元素 |
查找原范围内第一个在目标范围内包含的元素的位置 |
| adjacent_find() |
指向连续相同元素的首元素位置 |
查找连续相同元素的位置 |
| search_n() |
指向连续相同元素的首元素位置 |
查找连续相同指定数量个指定元素的位置 |
| search() |
指向找到的符合要求的首元素位置，未找到指向序列的末尾元素的下一个位置，即容器的end()位置 |
查找目标范围所有元素在原范围中的位置(需要匹配目标中的所有元素) |
| find_end() |
指向找到的符合要求的首元素位置，未找到指向序列的末尾元素的下一个位置，即容器的end()位置 |
从右向左找目标范围所有元素在原范围中的位置 |
std::vector<int> vctTest1 = {12,3,6,90,33,2,8,56,41,1};
std::vector<int> vctTest2 = {101,23,78,32,12,43,65,86,78,10};
std::cout << "find():" << *std::find(vctTest1.begin(), vctTest1.end(), 90) << std::endl;
auto itr = std::find(vctTest2.begin(), vctTest2.end(), 78);
std::cout << "find():" << std::distance(vctTest2.begin(), itr) << std::endl;
auto func4 = [](int &value)->bool{ return value > 30; };
std::cout << "find_if():" << std::distance(vctTest1.begin(), std::find_if(vctTest1.begin(), vctTest1.end(), func4)) << std::endl;
auto func5 = [](int &value)->bool{ return value < 30; };
std::cout << "find_if_not():" << std::distance(vctTest1.begin(), std::find_if_not(vctTest1.begin(), vctTest1.end(), func5)) << std::endl;
std::vector<int> vctTemp1({90,2,8,56});
auto itr1 = std::find_first_of(vctTest1.begin(), vctTest1.end(), vctTemp1.begin(), vctTemp1.end());
std::cout << "find_first_of():" << std::distance(vctTest1.begin(), itr1) << std::endl;
std::vector<int> vctTemp2({1,3,2,2,5,8});
auto itr2 = std::adjacent_find(vctTemp2.begin(), vctTemp2.end());
std::cout << "adjacent_find():" << std::distance(vctTemp2.begin(), itr2) << std::endl;
auto itr3 = std::search_n(vctTemp2.begin(), vctTemp2.end(), 2, 2);
std::cout << "search_n():" << std::distance(vctTemp1.begin(), itr3);
std::vector<int> vctTemp3({86,78,10});
auto itr4 = std::search(vctTest2.begin()+2, vctTest2.end(), vctTemp3.begin(), vctTemp3.end());
std::cout << "search():" << std::distance(vctTest2.begin(), itr4) << std::endl;
std::vector<int> vctTest3({86,78,10,1,3,2,4,86,78,10});
std::vector<int> vctTemp4({86,78,10,3});
auto itr5 = std::find_end(vctTest3.begin(), vctTest3.end(), vctTemp4.begin(), vctTemp4.end());
std::cout << "find_end():" << std::distance(vctTest3.begin(), itr5) << std::endl;
移位算法
| 函数 |
返回值 |
功能 |
| rotate() |
指向首个未移位元素移位后的位置 |
循环左移 |
| rotate_copy() |
迭代器 |
循环左移后，拷贝到目标序列中 |
std::string str = "abcdef";
std::rotate(str.begin(), str.begin()+3, str.end());
std::cout << "rotate():" << str << std::endl;
str = "abcedf";
std::string str1(6,0);
std::rotate_copy(str.begin(), str.begin()+3, str.end(), str1.begin());
std::cout << "rotate_copy():" << str1 << std::endl;
比较算法
| 函数 |
返回值 |
功能 |
| equal() |
相等返回true，否则返回false |
比较两个相同范围元素是否相同 |
| mismatch() |
指向两个序列中第一个不匹配的元素位置 |
比较两个序列中首个不匹配的元素 |
| lexicographical_compare() |
原字节序小于目标字节序时返回true，其他返回false |
字节序比较，比较原字节序是否比目标字节序小 |
std::vector<int> vctTest3({86,78,10,1,3,2,4,86,78,10});
std::vector<int> vctTemp4({86,78,10,3});
std::cout << "equal():" << std::boolalpha << std::equal(vctTest3.begin(), vctTest3.begin()+2, vctTemp4.begin()) << std::endl;
std::cout << "equal():" << std::boolalpha << std::equal(vctTest3.begin(), vctTest3.begin()+2, vctTemp4.begin(), vctTemp4.begin()+2) << std::endl;
auto itr6 = std::mismatch(vctTest3.begin(), vctTest3.end(), vctTemp4.begin());
std::cout << "mismatch():" << std::distance(vctTest3.begin(), itr6.first) << std::endl;
auto itr7 = std::mismatch(vctTest3.begin(), vctTest3.end(), vctTemp4.begin(), vctTemp4.end());
std::cout << "mismatch():" << std::distance(vctTest3.begin(), itr7.first) << std::endl;
std::string str1("abcdefg");
std::string str2("abdcdef");
std::cout << "lexicographical_compare():" << std::boolalpha
<< std::lexicographical_compare(str1.begin(), str1.end(), str2.begin(), str2.end()) << std::endl;
排序算法
| 函数名 |
返回值 |
功能 |
| sort() |
无 |
对序列的元素按照默认升序或自定义方式排序 |
| is_sorted() |
如果按照默认或自定义方式排序则返回true，否则返回false |
判断序列是否已经排序过 |
| is_sorted_until() |
指向首个没有被排序的元素位置 |
查找首个未排序的元素位置 |
| stable_sort() |
无 |
排序时确保有序或相同的元素相对位置不变 |
| partial_sort() |
无 |
对序列中的部分元素进行排序,保证指定位置左侧是有序的，或者根据自定义规则排序 |
| partial_sort_copy() |
指向目标序列的有效元素的下一个元素 |
将指定范围的元素排序好并拷贝到目标序列中 |
| nth_element() |
无 |
保证指定位置的元素是正确的，即左侧和右侧否符合排序规则 |
| partition() |
指向符合自定义元素的尾元素的下一个位置 |
按照自定义规则对序列分组 |
| is_partitioned() |
分好组时返回true，否则返回false |
判断序列是否按照自定义规则分好组 |
| partition_copy() |
返回键值对，分别指向分好组两部分的首元素 |
将指定序列按自定义规则分组并拷贝到目标序列中 |
| stable_partition() |
指向分好组时的边界位置 |
按自定义规则将指定序列分组 |
| binary_search() |
找到返回true，否则返回false |
二分查找法 |
| lower_bound() |
指向首个不小于指定元素的位置 |
查找首个不小于目标元素的位置 |
| upper_bound() |
指向首个大于指定元素的位置 |
查找首个大于目标元素的位置 |
| equal_range() |
返回首个不小于和大于指定元素的位置 |
查找首个不小于和大于目标元素的位置 |
| min_element() |
指向序列中的最小元素的位置 |
查找序列中的最小值 |
| max_max_element() |
指向序列中的最大元素的位置 |
查找序列中的最大值 |
| minmax_element() |
返回键值对，分别指向系列中元素的最大最小值 |
查找序列中的最大最小值 |
std::vector<int> vctTest({86,78,10,1,3,2,4,86,78,10});
std::sort(vctTest.begin(), vctTest.end());
std::cout << "sort():" ;
myprint(vctTest);
vctTest = {86,78,10,1,3,2,4,86,78,10};
std::stable_sort(vctTest.begin(), vctTest.end());
std::cout << "stable_sort():" ;
myprint(vctTest);
vctTest = {86,78,10,1,3,2,4,86,78,10};
std::partial_sort(vctTest.begin(), vctTest.begin()+5, vctTest.end());
std::cout << "partial_sort():" ;
myprint(vctTest);
vctTest = {86,78,10,1,3,2,4,86,78,10};
std::vector<int> vctTemp;
vctTemp.resize(5);
std::partial_sort_copy(vctTest.begin(), vctTest.begin()+5, vctTemp.begin(), vctTemp.end());
std::cout << "partial_sort_copy():" ;
myprint(vctTemp);
vctTest = {86,78,10,1,3,2,4,86,78,10};
std::nth_element(vctTest.begin(), vctTest.begin()+5, vctTest.end());
std::cout << "nth_element():" ;
myprint(vctTest);
vctTest = {86,78,10,1,3,2,4,86,78,10};
std::partition(vctTest.begin()+2, vctTest.begin()+6, [](int &value)->bool{return value < 5; });
std::cout << "partition():" ;
myprint(vctTest);
std::cout << "is_partitioned():" << std::boolalpha
<< std::is_partitioned(vctTest.begin()+2, vctTest.begin()+6, [](int &value)->bool{return value < 5; }) << std::endl;
vctTest = {86,78,10,1,3,2,4,86,78,10};
std::vector<int> vctTemp1;
vctTemp1.resize(5);
vctTemp.clear();
vctTemp.resize(5);
std::partition_copy(vctTest.begin()+2, vctTest.begin()+7,
vctTemp.begin(), vctTemp1.begin(),
[](int &value)->bool{return value < 5; });
std::cout << "partition_copy():" ;
myprint(vctTemp);
myprint(vctTemp1);
std::vector<int> vctTest4 = {1,3,2,4,8,5,7};
auto const func6 = [](int value){return value & 1; };
auto itr8 = std::stable_partition(vctTest4.begin(), vctTest4.end(), func6);
std::cout << "stable_partition():" ;
myprint(vctTest4);
vctTest = {1,2,3,4,5,6};
std::cout << "is_sorted():" << std::is_sorted(vctTest.begin(), vctTest.end()) << std::endl;
vctTest = {1,2,4,3,5,6};
auto itr9 = std::is_sorted_until(vctTest.begin(), vctTest.end());
std::cout << "is_sorted():" << std::distance(vctTest.begin(), itr9) << std::endl;
vctTest = {1,2,3,4,5,6};
std::cout << "binary_search():" << std::binary_search(vctTest.begin(), vctTest.end(), 3) << std::endl;
std::cout << "binary_search():" << std::binary_search(vctTest.begin(), vctTest.end(), 7) << std::endl;
std::cout << "lower_bound():" << *std::lower_bound(vctTest.begin(), vctTest.end(), 3) << std::endl;
std::cout << "upper_bound():" << *std::upper_bound(vctTest.begin(), vctTest.end(), 3) << std::endl;
auto pair1 = std::equal_range(vctTest.begin(), vctTest.end(), 3);
std::cout << "equal_range():" << "first=" << *pair1.first << " second=" << *pair1.second << std::endl;
std::cout << "min_element():" << *std::min_element(vctTest.begin(), vctTest.end()) << std::endl;
std::cout << "max_element():" << *std::max_element(vctTest.begin(), vctTest.end()) << std::endl;
vctTest = {1,2,3,4,5,6};
auto pair2 = std::minmax_element(vctTest.begin(), vctTest.end());
std::cout << "minmax_element():" << "min=" << *pair2.first << " second=" << *pair2.second << std::endl;
拷贝算法
| 函数 |
返回值 |
功能 |
| copy() |
目标序列的end()位置 |
拷贝指定序列的元素到目标序列中 |
| copy_n() |
目标序列的end()位置 |
拷贝指定位置开始的固定数量元素到目标序列中 |
| copy_backward() |
目标序列的end()位置 |
将原迭代器指定范围的元素从后向前拷贝到目标迭代器指定的位置 |
| copy_if() |
目标序列的end()位置 |
将原迭代器指定范围的符合条件的元素拷贝到目标迭代器指定的位置 |
std::vector<int> vctTest({86,78,10,1,3,2,4,86,78,10});
std::vector<int> vctTemp;
vctTemp.clear();
vctTemp.resize(5);
auto temp = std::copy(std::begin(vctTest), std::begin(vctTest)+5 , vctTemp.begin());
std::cout << "copy():";
myprint(vctTemp);
std::copy_n(std::begin(vctTest)+1, 5 , vctTemp.begin());
std::cout << "copy_n():";
myprint(vctTemp);
vctTemp.clear();
vctTemp.resize(5);
std::copy_backward(vctTest.begin(), vctTest.begin()+3 , vctTemp.begin()+5);
std::cout << "copy_backward():";
myprint(vctTemp);
vctTemp.clear();
vctTemp.resize(5);
std::copy_if(vctTest.begin(), vctTest.end() , vctTemp.begin(), [](int &value){return value < 3;});
std::cout << "copy_backward():";
myprint(vctTemp);
判断算法
| 函数 |
返回值 |
功能 |
| any_of() |
有任意满足条件元素返回true，否则返回false |
判断序列中是否有任意一个满足条件的元素 |
| all_of() |
所以元素都满足条件返回true，否则返回false |
判断序列中所有元素是否都满足条件 |
| none_of() |
无元素满足条件返回true，否则返回false |
判断序列中所有元素是否都不满足条件 |
| count() |
符合条件元素数量 |
统计指定元素的数量 |
| count_if() |
符合条件的元素数量 |
根据自定义规则统计元素数量 |
std::vector<int> vctTest1 = {12,3,6,90,33,2,8,56,41,1};
std::vector<int> vctTest2 = {101,23,78,32,12,43,65,86,78,10};
auto func = [](int &value)->bool{ return value > 100; };
std::cout << "any_of():" << std::any_of(vctTest1.begin(), vctTest1.end(), func) << std::endl;
std::cout << "any_of():" << std::any_of(vctTest2.begin(), vctTest2.end(), func) << std::endl;
auto func1 = [](int &value)->bool{ return value >= 10; };
std::cout << "all_of():" << std::all_of(vctTest1.begin(), vctTest1.end(), func1) << std::endl;
std::cout << "all_of():" << std::all_of(vctTest2.begin(), vctTest2.end(), func1) << std::endl;
auto func2 = [](int &value)->bool{ return value < 10; };
std::cout << "none_of():" << std::none_of(vctTest1.begin(), vctTest1.end(), func2) << std::endl;
std::cout << "none_of():" << std::none_of(vctTest2.begin(), vctTest2.end(), func2) << std::endl;
std::cout << "count():" << std::count(vctTest2.begin(), vctTest2.end(), 78) << std::endl;
auto func3 = [](int &value)->bool{ return value > 30; };
std::cout << "count_if():" << std::count_if(vctTest1.begin(), vctTest1.end(), func3) << std::endl;
元素填充
| 函数 |
返回值 |
功能 |
| fill() |
无 |
对指定序列范围填充固定元素 |
| fill_n() |
指向填充的最后一个元素的下一个位置 |
从指定位置开始填充固定个数个固定元素 |
| generate() |
无 |
按自定义规则对指定范围填充数据 |
| generate_n() |
指向填充的最后一个元素的下一个位置 |
按自定义规则对指定起始位置后填充固定个数的数据 |
| transform() |
指向目标序列的end() |
根据自定义规则对原序列元素进行操作并放入目标序列中 |
std::vector<int> vctTest({1,2,3,4,5,6});
std::fill(vctTest.begin(), vctTest.begin()+3, 8);
std::cout << "fill():" ;
myprint(vctTest);
vctTest = {1,2,3,4,5,6};
std::fill_n(vctTest.begin(), 3, 8);
std::cout << "fill_n():" ;
myprint(vctTest);
int value = 2;
auto fun1 = [&value]()mutable{
int tmp = value;
value += 2;;
return tmp;
};
std::generate(vctTest.begin(), vctTest.end(), fun1);
std::cout << "generate():" ;
myprint(vctTest);
std::generate_n(vctTest.begin(), 6, fun1);
std::cout << "generate_n():" ;
myprint(vctTest);
vctTest = {1,2,3,4,5,6};
std::vector<int> vctTemp;
vctTemp.resize(6);
auto func2 = [](int &value){return value*value;};
std::transform(vctTest.begin(), vctTest.end(), vctTemp.begin(),func2);
std::cout << "transform():" ;
myprint(vctTemp);
替换算法
| 函数 |
返回值 |
功能 |
| replace() |
无 |
将指定范围的原元素替换为目标元素 |
| replace_if() |
无 |
将指定范围按照自定义规则替换为目标元素 |
| replace_copy_if() |
指向目标序列的end()位置 |
将指定范围按照自定义规则替换为目标元素，并拷贝到新序列中 |
std::string str = "abcdefg";
std::replace(str.begin(), str.begin()+3, 'a', 'x');
std::cout << "replace:" << str << std::endl;
str = "abcdefg";
auto func1 = [](char &ch){
if(ch < 'c')
{
return true;
}
return false;
};
std::replace_if(str.begin(), str.begin()+6, func1, 'x');
std::cout << "replace_if():" << str << std::endl;
str = "abcdefg";
std::string strTemp;
strTemp.resize(10);
std::replace_copy_if(str.begin(), str.begin()+6, strTemp.begin(), func1, 'x');
std::cout << "replace_copy_if():" << strTemp << std::endl;
其他算法
| 函数 |
返回值 |
功能 |
| distance() |
返回两个迭代器之间的距离 |
计算两个迭代器之间的距离 |
| is_heap() |
序列是大根堆时返回true，否则返回false |
判断指定序列是否是大根堆 |
| is_heap_until() |
指向首个不是大根堆的元素位置 |
查找第一个不是大根堆的位置 |
| move() |
指向目标序列的end()位置 |
将原序列的元素移动到目标序列中 |
| sample() |
指向目标序列的end()位置 |
从原序列中随机选取指定数量的元素，并放在目标序列中 |
| iter_swap() |
无 |
交换两个位置的元素 |
| swap_ranges() |
指向目标序列的end()位置 |
交换两个序列指定范围的元素 |
| reverse() |
无 |
翻转指定序列的元素 |
| reverse_copy() |
指向目标序列的end()位置 |
翻转指定序列的元素，并拷贝到目标序列中 |
| shuffle() |
无 |
将指定序列的元素随机打乱 |
| iota() |
无 |
在指定序列中生成连续递增的元素 |
| reduce() |
累加和 |
对指定序列的元素进行自定义操作后的累加和 |
| adjacent_difference() |
指向目标序列的end()位置 |
计算原序列相邻元素的差值，并放置到目标序列 |
| inclusive_scan() |
指向目标序列的end()位置 |
算原序列元素的累加和，并放置到目标序列 |
std::vector<int> vctTest1 = {12,3,6,90,33,2,8,56,41,1};
std::vector<int> vctTest2 = {101,23,78,32,12,43,65,86,78,10};
std::vector<int> vctTest3({86,78,10,1,3,2,4,86,78,10});
std::vector<int> vctTemp4({86,78,10,3});
std::cout << "distance():" << std::distance(vctTest1.begin()+1, vctTest1.begin()+5) << std::endl;
vctTest1 = {9,7,8,6,2,1,4};
std::cout << "is_heap():" << std::is_heap(vctTest1.begin(), vctTest1.end()) << std::endl;
vctTest1 = {1,2,3,4,5};
std::cout << "is_heap_until():" << *(std::is_heap_until(vctTest1.begin(), vctTest1.end())) << std::endl;
std::string str3("abcdef");
std::string str4(5,0);
std::move(str3.begin()+1, str3.end(), str4.begin());
std::cout << "move():" << "str3=" << str3 << ",str4=" << str4 << std::endl;
std::string str5(4,0);
std::sample(str3.begin(), str3.end(), str5.begin(),4, std::default_random_engine(std::random_device{}()));
std::cout << "sample():" << "str5=" << str5 << std::endl;
std::string str6("hello world!");
std::string str7("welcome china!");
std::iter_swap(str6.begin(), str7.begin());
std::cout << "iter_swap():" << "str6=" << str6 << " str7=" << str7 << std::endl;
std::swap_ranges(str6.begin(), str6.end(), str7.begin());
std::cout << "swap_ranges():" << "str6=" << str6 << " str7=" << str7 << std::endl;
str6 = "abcedf";
std::cout << "reverse():" << "src=" << str6;
std::reverse(str6.begin(), str6.end());
std::cout << ",tag=" << str6 << std::endl;
std::string str8(6,0);
std::reverse_copy(str6.begin(), str6.end(),str8.begin());
std::cout << "reverse_copy():" << str8 << std::endl;
std::vector<int> vctTest4({1,2,3,4,5,6});
std::shuffle(vctTest4.begin(), vctTest4.end(), std::default_random_engine(std::random_device{}()));
std::cout << "shuffle():" ;
myprint(vctTest4);
std::vector<int> vctTest9;
vctTest9.resize(5);
std::iota(vctTest9.begin(), vctTest9.end(), 3);
std::cout << "iota():";
myprint(vctTest9);
std::cout << "reduce():" << std::reduce(vctTest9.begin(), vctTest9.end()) << std::endl;
auto func10 = [](int sum, int value ){ return sum*value; };
std::cout << "reduce():" << std::reduce(vctTest9.begin(), vctTest9.end(), 10, func10) << std::endl;
std::vector<int> vctTest6 {1,2,3,7,10,4};
std::vector<int> vctTest10;
vctTest10.resize(6);
std::adjacent_difference(vctTest6.begin(), vctTest6.end(), vctTest10.begin());
std::cout << "adjacent_difference():";
myprint(vctTest10);
std::vector<int> vctTest11;
vctTest11.resize(6);
std::inclusive_scan(vctTest6.begin(), vctTest6.end(), vctTest11.begin());
std::cout << "adjacent_difference():";
myprint(vctTest11);
