STL标准模板库之＜algorithm＞

测试环境

系统：ubuntu 22.04.2 LTS 64位
gcc版本：11.3.0
编辑器：vsCode 1.76.2

algorithm介绍

1. 其中封装了常用的算法

头文件

#include <algorithm>

//元素遍历
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()	指向目标序列中最后一个有效元素的下一个位置	删除指定范围连续重复元素，并将剩余元素拷贝到目标序列中

//1、remove移除指定范围内的指定元素，移除后的位置需要使用时，要注意迭代器失效问题（对以移除元素的位置打印可能是随机值）
std::vector<int> vctTest = {1,2,3,3,3,2,1};
std::remove(vctTest.begin(), vctTest.end(), 3);
std::cout << "remove():";
//已删除的位置不要是使用，删除位置的值为成为随机值
myprint(vctTest);

//2、remove_if根据自定义规则移除指定范围的元素
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);
    
//3、remove_copy对指定范围元素进行移除操作，并将删除后的元素复制到目标序列中
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);

//4、remove_copy_if对指定范围元素按自定义规则进行移除操作，并将删除后的元素复制到目标序列中
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);

//5、erase擦除容器中的指定元素(C++20中支持)
//6、erase按照自定义规则擦出容器中的指定元素（C++20中支持）

//7、unique删除指定范围内连续重复的元素
vctTest = {1,2,3,3,3,2,1};
std::unique(vctTest.begin(), vctTest.end());
std::cout << "unique():";
myprint(vctTest);

//8、unique_copy删除指定范围内连续重复元素，并将剩余元素复制到新的序列中
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};

//1、for_each遍历
std::cout << "for_each():";
for_each(vctTest.begin(), vctTest.end(), [](int &value){std::cout << value << "\t";});
std::cout << std::endl;

//2、for_each_n遍历
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;

//3、next获取指定迭代器位置的下一个或指定步数的位置
std::cout << "next():" << *(std::next(vctTest.begin(), 3)) << std::endl;

//4、prev获取指定迭代器位置的前一个或指定步数的位置
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};

//1、find查找与指定元素相同的首个元素的位置
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;

//2、find_if查找满足条件的首个元素的位置(找到第一个大于30的元素的位置)
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;

//3、find_if_not查找第一个不满足条件的元素的位置
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;

//4、find_first_of查找原范围内第一个在目标范围内包含的元素的位置。
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;

//5、adjacent_find查找连续相同元素的位置
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;

//6、search_n查找连续相同指定数量个指定元素的位置
auto itr3 = std::search_n(vctTemp2.begin(), vctTemp2.end(), 2, 2);
std::cout << "search_n():" << std::distance(vctTemp1.begin(), itr3);

//7、search查找目标范围所有元素在原范围中的位置(需要匹配目标中的所有元素)
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;

//8、find_end从右向左找目标范围所有元素在原范围中的位置
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";
//1、rotate循环左移
std::rotate(str.begin(), str.begin()+3, str.end());
std::cout << "rotate():" << str << std::endl;

//2、rotate_copy循环左移后并将其放置到目标序列中
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;

//3、shift_left左移操作，指定左移元素个数(C++20)
//4、shift_right右移操作，指定右移元素个数（C++23）

比较算法

函数	返回值	功能
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});
//1、equal比较两个范围元素是否相同，相同返回true，否则返回false
//1.1、根据第一组迭代器范围进行比较
std::cout << "equal():" << std::boolalpha << std::equal(vctTest3.begin(), vctTest3.begin()+2, vctTemp4.begin()) << std::endl;
//1.2、根据两组迭代器范围进行比较(根据原序列的指定范围进行比较)
std::cout << "equal():" << std::boolalpha << std::equal(vctTest3.begin(), vctTest3.begin()+2, vctTemp4.begin(), vctTemp4.begin()+2) << std::endl;

//2、mismatch找到两个范围第一个不一样的元素,返回、pair值，表示两个序列不一样元素的位置
//2.1、根据第一组迭代器范围进行比较
auto itr6 = std::mismatch(vctTest3.begin(), vctTest3.end(), vctTemp4.begin());
std::cout << "mismatch():" << std::distance(vctTest3.begin(), itr6.first) << std::endl;
//2.2、根据两组迭代器范围进行比较
auto itr7 = std::mismatch(vctTest3.begin(), vctTest3.end(), vctTemp4.begin(), vctTemp4.end());
std::cout << "mismatch():" << std::distance(vctTest3.begin(), itr7.first) << std::endl;

//3、lexicographical_compare字节序比较，第一个迭代器范围字节序小于第二个迭代器范围字节序时返回true，否则返回false
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});
//1、sort排序
std::sort(vctTest.begin(), vctTest.end());
std::cout << "sort():" ;
myprint(vctTest);

//2、stable_sort排序，区别与sort为序列中相同元素的相对位置不会发生改变，、sort排序可能出现相同元素的位置交换
vctTest = {86,78,10,1,3,2,4,86,78,10};
std::stable_sort(vctTest.begin(), vctTest.end());
std::cout << "stable_sort():" ;
myprint(vctTest);

//3、partail_sort排序，对序列中的部分元素进行排序,保证指定位置左侧是有序的，或者根据自定义规则排序
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);

//4、partail_sort_copy排序，对序列中的部分元素进行排序并拷贝到目标序列中
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);

//5、nth_element保证指定位置是元素是正确的，即左边元素和右边元素都满足条件 
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);

//6、partition对指定范围元素按自定义条件分组
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);

//7、is_partitioned判断序列是否按照指定规则分组
std::cout << "is_partitioned():" << std::boolalpha 
          << std::is_partitioned(vctTest.begin()+2, vctTest.begin()+6, [](int &value)->bool{return value < 5; }) << std::endl;

//8、partition_copy对指定范围元素按自定义条件分组,并拷贝到目标序类中
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);

//9、stable_partition保证序列中元素相对位置不变进行排序
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);

//10、is_sorted判断指定迭代器范围元素是否排过序
vctTest = {1,2,3,4,5,6};
std::cout << "is_sorted():" << std::is_sorted(vctTest.begin(), vctTest.end()) << std::endl;

//11、is_sorted_until查找第一个未排序元素的位置
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;

//12、binary_search二分查找，找到返回true，否则返回false，元素需要有序
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;

//13、lower_bound查找第一个不小于指定值的首元素的位置
std::cout << "lower_bound():" << *std::lower_bound(vctTest.begin(), vctTest.end(), 3) << std::endl;

//14、upper_bound查找第一个大于指定值的首元素的位置
std::cout << "upper_bound():" << *std::upper_bound(vctTest.begin(), vctTest.end(), 3) << std::endl;

//15、equal_range查找指定值的上下区间，不小于指定值的首元素位置和大于指定值的首元素的位置
auto pair1 = std::equal_range(vctTest.begin(), vctTest.end(), 3);
std::cout << "equal_range():" << "first=" << *pair1.first << " second=" << *pair1.second << std::endl;

//16、includs判断第二组迭代器范围是否是第一组迭代器范围的子集，是返回true，否则返回false
//std::vector<int> vctTemp7({4,5,6});
//std::cout << "includes():" << std::includes(vctTest.begin(), vctTest.end(), vctTemp7.begin(), vctTemp7.begin()+2) << std::endl;

//17、min_element查找迭代器指定范围中的最小值的位置
std::cout << "min_element():" << *std::min_element(vctTest.begin(), vctTest.end()) << std::endl;

//18、max_elemetn查找迭代器指定范围中的最大值的位置
std::cout << "max_element():" << *std::max_element(vctTest.begin(), vctTest.end()) << std::endl;

//19、minmax_element查找最大最小值，返回一个pair,第一个是最小值，第二个是最大值
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;
//1、copy将指定的第一组迭代器指定范围的元素赋值到第二组迭代器指定的位置
vctTemp.clear();
vctTemp.resize(5);
auto temp = std::copy(std::begin(vctTest), std::begin(vctTest)+5 , vctTemp.begin());
std::cout << "copy():";
myprint(vctTemp);

//2、copy_n从原迭代器指定范围拷贝n个元素到目标迭代器指定的位置
std::copy_n(std::begin(vctTest)+1, 5 , vctTemp.begin());
std::cout << "copy_n():";
myprint(vctTemp);

//3、copy_backward将原迭代器指定范围的元素从后向前拷贝到目标迭代器指定的位置
vctTemp.clear();
vctTemp.resize(5);
std::copy_backward(vctTest.begin(), vctTest.begin()+3 , vctTemp.begin()+5);
std::cout << "copy_backward():";
myprint(vctTemp);

//4、copy_if将原迭代器指定范围的符合条件的元素拷贝到目标迭代器指定的位置
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};

//1、any_of有任何一个满足条件则返回true，否则返回false
auto func = [](int &value)->bool{ return value > 100; };
std::cout << "any_of():" << std::any_of(vctTest1.begin(), vctTest1.end(), func) << std::endl; //false
std::cout << "any_of():" << std::any_of(vctTest2.begin(), vctTest2.end(), func) << std::endl; //true

//2、all_of所有元素都满足条件则返回true，否则返回false
auto func1 = [](int &value)->bool{ return value >= 10; };
std::cout << "all_of():" << std::all_of(vctTest1.begin(), vctTest1.end(), func1) << std::endl; //false
std::cout << "all_of():" << std::all_of(vctTest2.begin(), vctTest2.end(), func1) << std::endl; //true

//3、none_of没有1个元素满足条件则返回true，否则返回false
auto func2 = [](int &value)->bool{ return value < 10; };
std::cout << "none_of():" << std::none_of(vctTest1.begin(), vctTest1.end(), func2) << std::endl; //false
std::cout << "none_of():" << std::none_of(vctTest2.begin(), vctTest2.end(), func2) << std::endl; //true

//4、count统计指定元素的数量
std::cout << "count():" << std::count(vctTest2.begin(), vctTest2.end(), 78) << std::endl;

//5、count_if统计符合条件元素的数量
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});
//1、fill填充指定范围内元素为固定值
std::fill(vctTest.begin(), vctTest.begin()+3, 8);
std::cout << "fill():" ;
myprint(vctTest);

//2、fill_n从指定位置开始填充指定数量的元素为固定值
vctTest = {1,2,3,4,5,6};
std::fill_n(vctTest.begin(), 3, 8);
std::cout << "fill_n():" ;
myprint(vctTest);

//3、generate按自定义规则生成填充数据
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);

//4、generate_n按自定义规则生成指定数量个元素填充数据
std::generate_n(vctTest.begin(), 6, fun1);
std::cout << "generate_n():" ;
myprint(vctTest);

//5、transform按自定义规则对指定序列进行操作并放入目标序列中
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()位置	将指定范围按照自定义规则替换为目标元素，并拷贝到新序列中

//1、replace将原范围内指定元素替换为目标元素
std::string str = "abcdefg";
std::replace(str.begin(), str.begin()+3, 'a', 'x');
std::cout << "replace:" << str << std::endl;

//2、replace_if根据自定义规则替换原范围内的元素为目标元素
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;

//3、replace_copy_if根据自定义规则替换原范围内的元素为目标元素，并复制到新序列中
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});

//1、distance计算迭代器之间的距离
std::cout << "distance():" << std::distance(vctTest1.begin()+1, vctTest1.begin()+5) << std::endl;

//2、is_heap判断序类是否为大根堆   
vctTest1 = {9,7,8,6,2,1,4};
std::cout << "is_heap():" << std::is_heap(vctTest1.begin(), vctTest1.end()) << std::endl;

//3、is_heap_until查找第一个不是大根堆的元素位置
vctTest1 = {1,2,3,4,5};
std::cout << "is_heap_until():" << *(std::is_heap_until(vctTest1.begin(), vctTest1.end())) << std::endl;

//4、move将原迭代器指定范围元素移动到目标迭代器指定的位置，移动之后原迭代器元素为空
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;

//5、sample随机选取原迭代器指定范围的指定数量的元素
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;

//6、iter_swap交换两个迭代器指定的元素值
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; 

//7、swap_ranges交换两个迭代器指定范围的元素
std::swap_ranges(str6.begin(), str6.end(), str7.begin());
std::cout << "swap_ranges():" << "str6=" << str6 << " str7=" << str7 << std::endl; 

//8、reverse翻转指定迭代器范围的元素值
str6 = "abcedf";
std::cout << "reverse():" << "src=" << str6;
std::reverse(str6.begin(), str6.end());
std::cout << ",tag=" << str6 << std::endl;

//9、reverse_copy翻转原迭代器范围的元素并复制到指定迭代器中
std::string str8(6,0);
std::reverse_copy(str6.begin(), str6.end(),str8.begin());
std::cout << "reverse_copy():" << str8 << std::endl;

//10、shuffle将指定范围的有序元素序列随机打乱
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);

//以下函数需要包含头文件<numeric>
//11、iota在指定序列中生成从指定值开始的连续递增序列
std::vector<int> vctTest9;
vctTest9.resize(5);
std::iota(vctTest9.begin(), vctTest9.end(), 3);
std::cout << "iota():";  
myprint(vctTest9);

//12、reduce对指定范围内的元素进行累加操作
std::cout << "reduce():" << std::reduce(vctTest9.begin(), vctTest9.end()) << std::endl;

//13、reduce对指定范围内的元素进行自定义操作（累加、累乘等）
auto func10 = [](int sum, int value ){ return sum*value; };
std::cout << "reduce():" << std::reduce(vctTest9.begin(), vctTest9.end(), 10, func10) << std::endl;

//14、adjacent_difference计算原序列中元素间的差值，首元素不变
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);

//15、inclusive_scan计算原序列中当前位置及之前元素的累加值，首元素不变
std::vector<int> vctTest11;
vctTest11.resize(6);
std::inclusive_scan(vctTest6.begin(), vctTest6.end(), vctTest11.begin());
std::cout << "adjacent_difference():";  
myprint(vctTest11);