c++中的 Stl 算法(很乱别看)

 #include <iostream>
 #include <vector>
 #include <functional>
 #include <algorithm>
 #include <string>
 #include <array>
 #include <ctime>
 #include <cstdlib>
 #include <random>
 #include <list>

 int main()
 {
     std::vector<int> vec{, , , , , };

     //1.简单查找

     //return iterator by value/unaryPred
     //查找单值出现位置
     std::cout<<*std::find(vec.begin(),vec.end(),)<<std::endl;
     std::cout<<*std::find_if(vec.begin(),vec.end(),[](int& value){return value==;})<<std::endl;
     std::cout<<*std::find_if_not(vec.begin(),vec.end(),[](int& value){return value==;})<<std::endl;

     //return times by value/unaryPred
     std::cout<<std::count(vec.begin(),vec.end(),)<<std::endl;
     std::cout<<std::count_if(vec.begin(),vec.end(),[](int& value){return value==;})<<std::endl;

     //return bool by unaryPred;
     //对序列元素调用一元谓词
     std::cout<<std::boolalpha;
     std::cout<<std::all_of(vec.begin(),vec.end(),[](int& value){return typeid(value)==typeid(int&);})<<std::endl;
     std::cout<<std::any_of(vec.begin(),vec.end(),[](int& value){return value==;})<<std::endl;
     std::cout<<std::none_of(vec.begin(),vec.end(),[](int& value){return value==;})<<std::endl;
     std::cout<<std::noboolalpha;

     //2.查找重复值

     //return iterator by NULL/binaryPred
     //返回查找第一个相邻重复元素迭代器
     std::cout<<*std::adjacent_find(vec.begin(),vec.end())<<std::endl;
     std::cout<<*std::adjacent_find(vec.begin()+,vec.end(),[](int& a,int& b){return a==b;})<<std::endl;

     //return iterator by binaryPred
     //查找某个数是否出现一定次数,返回第一个元素迭代器
     std::cout<<*std::search_n(vec.begin(),vec.end(),,)<<std::endl;
     std::cout<<*std::search_n(vec.begin(),vec.end(),,,[](int a,int b){ return a==b;})<<std::endl;

     //3.查找子序列方法

     //return iterator by NULL/binaryPred
     //从第一个序列中查找第二个序列,返回第二个序列在第一个序列出现的迭代器
     std::vector<int> vec_cm{,,,,,};
     std::cout<<*std::search(vec.begin(),vec.end(),vec_cm.begin(),vec_cm.end())<<std::endl;
     std::cout<<*std::search(vec.begin(),vec.end(),vec_cm.begin(),vec_cm.end(),[](int& a,int& b){return a==b;})<<std::endl;

     //返回一个迭代器指向第二个序列任意元素在第一个序列中出现的位置
     std::cout<<*std::find_first_of(vec.begin(),vec.end(),vec_cm.begin(),vec_cm.end())<<std::endl;
     std::cout<<*std::find_first_of(vec.begin(),vec.end(),vec_cm.begin(),vec_cm.end(),[](int& a,int& b){return a==b;})<<std::endl;

     //类似search，返回序列的尾部
     //std::find_end();

     //其他只读算法

     //熟知的std::for_each();
     //对序列每个元素指向可调用对象,对返回值忽略
     std::for_each(vec.begin(),vec.end(),[](int& value){std::cout<<value<<"\t";});
     std::cout<<std::endl;

     //比较两序列,返回pair first指向一个不同位置迭代器和second指向第二个相同位置迭代器(~.~)
     std::pair<std::vector<int>::iterator,std::vector<int>::iterator> pair1=
             std::mismatch(vec.begin(),vec.end(),vec_cm.begin());
 //    std::pair<std::vector<int>::iterator,std::vector<int>::iterator> pair2=
 //            std::mismatch(vec.begin(),vec.end(),vec_cm.begin(),[](int& a,int& b){});
     std::cout<<*pair1.first<<*pair1.second<<std::endl;

     //判断2序列相等,则返回true
     std::cout<<std::boolalpha;
     std::cout<<std::equal(vec.begin(),vec.end(),vec_cm.begin())<<std::endl;
     std::cout<<std::equal(vec.begin(),vec.end(),vec_cm.begin(),[](int& a,int& b){ return true;})<<std::endl;
     std::cout<<std::noboolalpha;

     // 二分法搜索
     // 这些算法要求前向迭代器，这样花费时间类似线性增长而不是对数增长
     // 前提序列有序
     // 注意:(有毒)
     std::cout << *std::lower_bound(vec.begin(), vec.end(), ) << std::endl;
     std::cout << *std::upper_bound(vec.begin(), vec.end(), ) << std::endl;

     //懵- -
     auto pair=std::equal_range(vec.begin(),vec.end(),);
     std::cout<<*pair.first<<*pair.second<<std::endl;

     std::cout << std::boolalpha;
     std::cout<<std::binary_search(vec.begin(),vec.end(),)<<std::endl;
     std::cout << std::noboolalpha;

     //拷贝算法

     std::vector<int> vec3_;
     vec3_.resize(vec.size());
     //按第一序列范围拷贝;
     std::copy(vec.begin(),vec.end(),vec3_.begin());
     //按谓词拷贝
     std::copy_if(vec.begin(),vec.end(),vec3_.begin(),[](int& value){ return value>;});
     //按数量拷贝,返回尾元素
     std::copy_n(vec.begin(),vec.size(),vec.begin());

     //对元素调用std::move()移动
     std::move(vec.begin(),vec.end(),vec.begin());

     std::vector<int> vec4_;
     vec4_.resize(vec.size());
 //    //对第一序列执行一元谓词拷贝到第二序列中
 //    std::transform(vec.begin(),vec.end(),vec4_.begin(),[](int& value){return value>0;});
 //
 //    //对2序列执行二元谓词放入第三序列
     std::vector<int> vec5_;
 //    vec5_.resize(vec.size()+vec4_.size());
 //    std::transform(vec.begin(),vec.end(),vec4_.begin(),vec5_.begin(),[](int& a,int& b){ return a==b;});

     //拷贝一个序列到另一个序列,与oldvalue比较相等的则在新序列中替换成新值
     std::replace_copy(vec.begin(),vec.end(),vec4_.begin(),,);

     //根据一元谓词条件判断那些值需要被替换成新值
     std::replace_copy_if(vec.begin(),vec.end(),vec4_.begin(),[](int& value){return value>;},);

     //合并2序列到第三序列
     //默认降序,可自行设置二元谓词比较
     //前提:有序序列
     std::merge(vec.begin(),vec.end(),vec4_.begin(),vec4_.end(),vec5_.begin());
     std::merge(vec.begin(),vec.end(),vec4_.begin(),vec4_.end(),vec5_.begin(),[](int& a,int& b){return a<b;});

     //同类型迭代器之间交换
     std::vector<int> vec8_{,,,};
     std::for_each(vec.begin(),vec.end(),[](int& value){std::cout<<value<<"\t";});
     std::cout<<std::endl;
     std::for_each(vec8_.begin(),vec8_.end(),[](int& value){std::cout<<value<<"\t";});
     std::cout<<std::endl;

     std::iter_swap(vec.begin(),vec.begin()+);
     std::iter_swap(vec.begin(),vec8_.begin()+);
     std::swap_ranges(vec8_.begin(),vec8_.end(),vec.begin());

     std::for_each(vec.begin(),vec.end(),[](int& value){std::cout<<value<<"\t";});
     std::cout<<std::endl;
     std::for_each(vec8_.begin(),vec8_.end(),[](int& value){std::cout<<value<<"\t";});
     std::cout<<std::endl;

     //单序列操作replace/replace_if 区别 replace_copy/replace_copy_if
     //值对比或者unaryPred查找;
     std::vector<int> vec9_{,,,,,,};

     std::replace(vec9_.begin(),vec9_.end(),,);
     std::cout<<vec9_[]<<std::endl;
     std::replace_if(vec9_.begin(),vec9_.end(),[](int& value){return value%==;},);

     std::for_each(vec9_.begin(),vec9_.end(),[](int &value){std::cout<<value<<"\t";});
     std::cout<<std::endl;

     //划分算法
     std::vector<int> sort_vec{,,,,,,,,};

     for(auto& iter:sort_vec)std::cout<<iter<<"\t";
     //是否符合划分谓词条件,true在前false在后
     if(std::is_partitioned(sort_vec.begin(),sort_vec.end(),[](int& value){return value%==;}))
     {
         std::cout<<"(Partition)"<<std::endl;
     }else
     {
         std::cout<<"(No partition)"<<std::endl;
     }

     //划分操作,返回谓词为true队列的后一位迭代器;全是false的话返回beg;
     std::partition(sort_vec.begin(),sort_vec.end(),[](int& value){ return value%==;});
     //std::partition_point(...)  返回partition的迭代器- -(好鸡肋)；

     for(auto& iter:sort_vec)std::cout<<iter<<"\t";
     if(std::is_partitioned(sort_vec.begin(),sort_vec.end(),[](int& value){return value%==;}))
     {
         std::cout<<"(Partition)"<<std::endl;
     }else
     {
         std::cout<<"(No partition)"<<std::endl;
     }

     //从一个序列中划分出符合谓词条件的2部分(true/false);
     std::array<int,> sort_array1,sort_array2;
     std::partition_copy(sort_vec.begin(),sort_vec.end(),sort_array1.begin(),sort_array2.begin(),[](int& value){return value%==;});

     for(auto& iter:sort_array1)std::cout<<iter<<"\t";
     std::cout<<std::endl;
     for(auto& iter:sort_array2)std::cout<<iter<<"\t";

    // 正常排序

     std::array<int,> sort_array{,,,,,,,,,,,};
     //排序算法
     //std::stable_sort 稳定排序
     std::sort(sort_array.begin(),sort_array.end());
     //std::sort(sort_array.begin(),sort_array.end(),[](int& a,int& b){return a>=b;});

     if(std::is_sorted(sort_array.begin(),sort_array.end()))
     {
         std::cout<<"sort"<<std::endl;
     }else
     {
         std::cout<<"not sort"<<std::endl;
     }

     //快速排序
     std::array<int,> sort_array{,,,,,,,,,,,};

     std::nth_element(sort_array.begin(),sort_array.begin()+,sort_array.end());

     for(auto& iter:sort_array)std::cout<<iter<<"\t";

     //重排序列算法

     std::array<int,> sort_array{,,,,,,,,,,,};
     //删除符合条件的,用保留的元素覆盖删除元素
     std::remove(sort_array.begin(),sort_array.end(),);
     std::remove_if(sort_array.begin(),sort_array.end(),[](int& value){return value%==;});
     //std::remove_copy(sort_array.begin(),sort_array.end(),dest,value);
     //std::remove_copy_if(sort_array.begin(),sort_array.end(),dest,comp);

     //序列相邻重复元素删除，通过覆盖删除
     //std::unique(beg,end);
     //std::unique(beg,end,binaryPred);
     //std::unique_copy(beg,end,dest)
     //std::unique_copy_if(beg,end,dest,binaryPred);

     for(auto& iter:sort_array)std::cout<<iter<<"\t";

     //截取序列,从某个元素到end之间的范围 截取到beg之前
     std::vector<int>  vec18{,,,,,,,,};

     std::rotate(vec18.begin(),vec18.begin()+,vec18.end());
     //std::rotate_copy(beg,mid,end,dest);

     for(auto& iter:vec18)std::cout<<iter<<"\t";

     //翻转序列
     //std::reverse(beg,end);
     //std::reverse(beg,end,dest);

     //随机序列
     std::vector<int> random_vec{, , , , , , , };

     unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
     // std::random_shuffle(random_vec.begin(),random_vec.end());
     //std::random_shuffle(random_vec.begin(),random_vec.end(),[](int seed){return std::rand()%seed;});
     std::shuffle(random_vec.begin(), random_vec.end(), std::default_random_engine(seed));

     for (auto &iter:random_vec)std::cout << iter << "\t";

     //排列算法

     std::vector<int> vec1{, , , , , };
     std::vector<int> vec2{, , , , , };

     //2序列是否是1序列的排列,是返回true;
     //可以添加bianryPred选择排列方式
     if (std::is_permutation(vec1.begin(), vec1.end(), vec2.begin()))
         std::cout << "vec2 is_permutation belong vec1" << std::endl;

     //1 2 3
     //1 3 2
     //2 1 3
     //2 3 1
     //3 1 2
     //3 2 1
     //根据字典序列排序,默认降序排序,比如(1 2 3) ,首元素排列中1最小且第二个元素2小于排列(1 3 2),所以排列(1 2 3)在第一个，其他依次类推;
     std::vector<int> vec_permutation{,,};
     do
     {
         std::cout<<vec_permutation[]<<" "<<vec_permutation[]<<" "<<vec_permutation[]<<std::endl;

         //可以添加bianryPred选择排列方式
         //std::pre_permutation为序列反向
     }while(std::next_permutation(vec_permutation.begin(),vec_permutation.end()));

     //最后容器元素被置为靠头第一个排列

     //字典序列比较
     std::lexicographical_compare(beg,end,beg2,end2);
     std::lexicographical_compare(beg,end,beg2,end2,comp);

     //容器1是否包含在容器2的元素
     int container[] = {,,,,,,,,,};
     int continent[] = {,,,};

     std::sort (container,container+);
     std::sort (continent,continent+);

     // using default comparison:
     if ( std::includes(container,container+,continent,continent+) )
         std::cout << "container includes continent!\n";

     // using myfunction as comp:
     if ( std::includes(container,container+,continent,continent+, [](int& a,int& b){ return a<b; }) )
         std::cout << "container includes continent!\n";

     std::set_union 把2有序的序列合并成一个有序序列到第三个容器中
     int first[] = {,,,,};
     int second[] = {,,,,};
     std::vector<int> v();                      // 0  0  0  0  0  0  0  0  0  0
     std::vector<int>::iterator it;

     std::sort (first,first+);     //  5 10 15 20 25
     std::sort (second,second+);   // 10 20 30 40 50

     it=std::set_union (first, first+, second, second+, v.begin());
     // 5 10 15 20 25 30 40 50  0  0
     v.resize(it-v.begin());                      // 5 10 15 20 25 30 40 50

     std::cout << "The union has " << (v.size()) << " elements:\n";
     for (it=v.begin(); it!=v.end(); ++it)
         std::cout << ' ' << *it;
     std::cout << '\n';

     std::vector<int> int_vec1{,,,,,,,,};
     std::vector<int> int_vec2{,,};
     std::vector<int> int_vec;
     int_vec.resize();
     //寻找交集
     std::set_intersection(int_vec1.begin(),int_vec1.end(),int_vec2.begin(),int_vec2.end(),int_vec.begin());
     for(auto& iter:int_vec)std::cout<<iter<<std::endl;

     出现在第一个序列，但不出现在第二个序列

     std::vector<int> int_vec1{, , , , , , , , };
     std::vector<int> int_vec2{, , };
     std::vector<int> int_vec();

     std::set_difference(int_vec1.begin(),int_vec1.end(),int_vec2.begin(),int_vec2.end(),int_vec.begin());

     for(auto& iter:int_vec)std::cout<<iter<<std::endl;

     //非交集区域

     std::vector<int> int_vec1{, , , , , , , , };
     std::vector<int> int_vec2{, , };
     std::vector<int> int_vec();

     auto end=std::set_symmetric_difference(int_vec1.begin(),int_vec1.end(),int_vec2.begin(),int_vec2.end(),int_vec.begin());
     int_vec.resize(end-int_vec.begin());

     for(auto& iter:int_vec)std::cout<<iter<<std::endl;

     //前两个应用值比较或者初始化链表值比较

     std::initializer_list<int> li{,,,,,,,};

     std::cout<<std::max(,)<<std::endl;
     std::cout<<std::min(,)<<std::endl;
     std::cout<<std::min(li)<<std::endl;
     std::cout<<std::max(li)<<std::endl;
     auto pair=std::minmax(li);
     std::cout<<pair.first<<" "<<pair.second<<std::endl;

     std::vector<int> in_vec{,,,,,,};

     std::cout<<*std::min_element(in_vec.begin(),in_vec.end())<<std::endl;
     std::cout<<*std::max_element(in_vec.begin(),in_vec.end())<<std::endl;
     auto pair_=std::minmax_element(in_vec.begin(),in_vec.end());
     std::cout<<*pair_.first<<" "<<*pair_.second<<std::endl;

     //数值算法

     //容器累和,sum代表初值
     int array[]={,,,,,,};
     int sum=;
     std::cout<<std::accumulate(array,array+,sum)<<std::endl;
     std::cout<<std::accumulate(array,array+,sum,[](int& a,int& b){ return a+b;})<<std::endl;
     std::cout<<sum<<std::endl;

     //容器元素对应想乘求和
     int myaccumulator (int x, int y) {return x-y;}
     int myproduct (int x, int y) {return x+y;}

     int init = ;
     int series1[] = {,,};
     int series2[] = {,,};

     std::cout << "using default inner_product: ";
     std::cout << std::inner_product(series1,series1+,series2,init);
     std::cout << '\n';

     std::cout << "using functional operations: ";
     std::cout << std::inner_product(series1,series1+,series2,init,
                                     std::minus<int>(),std::divides<int>());
     std::cout << '\n';

     std::cout << "using custom functions: ";
     std::cout << std::inner_product(series1,series1+,series2,init,
                                     myaccumulator,myproduct);
     std::cout << '\n';

     //序列当前位置到beg范围求和.当前位置递增
     int array[]={,,,,,,};
     int result[]{};
     std::partial_sum(array,array+,result);
     for(auto& iter:result)std::cout<<iter<<"\t";
     std::cout<<std::endl;

     //当前位置减去前一个元素
     int array[] = {, , , , , , };
     int result[]{};
     std::adjacent_difference(array, array + , result);
     for (auto &iter:result)std::cout << iter << "\t";
     std::cout << std::endl;

     //填充容器给定数值递增
     int array[];
     std::iota(array,array+,);
     for(auto& iter:array)std::cout<<iter<<"\t";
     std::cout<<std::endl;

     return ;
 }