C++STL库之algorithm库

algorithm库函数集合：

不修改内容的序列操作：

adjacent_find	查找两个相邻（Adjacent）的等价（Identical）元素
all_ofC++11	检测在给定范围中是否所有元素都满足给定的条件
any_ofC++11	检测在给定范围中是否存在元素满足给定条件
count	返回值等价于给定值的元素的个数
count_if	返回值满足给定条件的元素的个数
equal	返回两个范围是否相等
find	返回第一个值等价于给定值的元素
find_end	查找范围A中与范围B等价的子范围最后出现的位置
find_first_of	查找范围A中第一个与范围B中任一元素等价的元素的位置
find_if	返回第一个值满足给定条件的元素
find_if_notC++11	返回第一个值不满足给定条件的元素
for_each	对范围中的每个元素调用指定函数
mismatch	返回两个范围中第一个元素不等价的位置
none_ofC++11	检测在给定范围中是否不存在元素满足给定的条件
search	在范围A中查找第一个与范围B等价的子范围的位置
search_n	在给定范围中查找第一个连续n个元素都等价于给定值的子范围的位置

修改内容的序列操作：

copy	将一个范围中的元素拷贝到新的位置处
copy_backward	将一个范围中的元素按逆序拷贝到新的位置处
copy_ifC++11	将一个范围中满足给定条件的元素拷贝到新的位置处
copy_nC++11	拷贝 n 个元素到新的位置处
fill	将一个范围的元素赋值为给定值
fill_n	将某个位置开始的 n 个元素赋值为给定值
generate	将一个函数的执行结果保存到指定范围的元素中，用于批量赋值范围中的元素
generate_n	将一个函数的执行结果保存到指定位置开始的 n 个元素中
iter_swap	交换两个迭代器（Iterator）指向的元素
moveC++11	将一个范围中的元素移动到新的位置处
move_backwardC++11	将一个范围中的元素按逆序移动到新的位置处
random_shuffle	随机打乱指定范围中的元素的位置
remove	将一个范围中值等价于给定值的元素删除
remove_if	将一个范围中值满足给定条件的元素删除
remove_copy	拷贝一个范围的元素，将其中值等价于给定值的元素删除
remove_copy_if	拷贝一个范围的元素，将其中值满足给定条件的元素删除
replace	将一个范围中值等价于给定值的元素赋值为新的值
replace_copy	拷贝一个范围的元素，将其中值等价于给定值的元素赋值为新的值
replace_copy_if	拷贝一个范围的元素，将其中值满足给定条件的元素赋值为新的值
replace_if	将一个范围中值满足给定条件的元素赋值为新的值
reverse	反转排序指定范围中的元素
reverse_copy	拷贝指定范围的反转排序结果
rotate	循环移动指定范围中的元素
rotate_copy	拷贝指定范围的循环移动结果
shuffleC++11	用指定的随机数引擎随机打乱指定范围中的元素的位置
swap	交换两个对象的值
swap_ranges	交换两个范围的元素
transform	对指定范围中的每个元素调用某个函数以改变元素的值
unique	删除指定范围中的所有连续重复元素，仅仅留下每组等值元素中的第一个元素。
unique_copy	拷贝指定范围的唯一化（参考上述的 unique）结果

划分操作：

is_partitionedC++11	检测某个范围是否按指定谓词（Predicate）划分过
partition	将某个范围划分为两组
partition_copyC++11	拷贝指定范围的划分结果
partition_pointC++11	返回被划分范围的划分点
stable_partition	稳定划分，两组元素各维持相对顺序

排序操作：

is_sortedC++11	检测指定范围是否已排序
is_sorted_untilC++11	返回最大已排序子范围
nth_element	部份排序指定范围中的元素，使得范围按给定位置处的元素划分
partial_sort	部份排序
partial_sort_copy	拷贝部分排序的结果
sort	排序
stable_sort	稳定排序

二分法查找操作：

binary_search	判断范围中是否存在值等价于给定值的元素
equal_range	返回范围中值等于给定值的元素组成的子范围
lower_bound	返回指向范围中第一个值大于或等于给定值的元素的迭代器
upper_bound	返回指向范围中第一个值大于给定值的元素的迭代器

集合操作：

includes	判断一个集合是否是另一个集合的子集
inplace_merge	就绪合并
merge	合并
set_difference	获得两个集合的差集
set_intersection	获得两个集合的交集
set_symmetric_difference	获得两个集合的对称差
set_union	获得两个集合的并集

堆操作：

is_heap	检测给定范围是否满足堆结构
is_heap_untilC++11	检测给定范围中满足堆结构的最大子范围
make_heap	用给定范围构造出一个堆
pop_heap	从一个堆中删除最大的元素
push_heap	向堆中增加一个元素
sort_heap	将满足堆结构的范围排序

最大/最小操作：

is_permutationC++11	判断一个序列是否是另一个序列的一种排序
lexicographical_compare	比较两个序列的字典序
max	返回两个元素中值最大的元素
max_element	返回给定范围中值最大的元素
min	返回两个元素中值最小的元素
min_element	返回给定范围中值最小的元素
minmaxC++11	返回两个元素中值最大及最小的元素
minmax_elementC++11	返回给定范围中值最大及最小的元素
next_permutation	返回给定范围中的元素组成的下一个按字典序的排列
prev_permutation	返回给定范围中的元素组成的上一个按字典序的排列

一，巡防算法

for_each(容器起始地址，容器结束地址，要执行的方法)

[html] view
plain copy

#include <iostream>

#include <algorithm>

#include <vector>

using namespace std;

template<class T>

struct plus2

{

void operator()(T&x)const

{

x+=2;

}

};

void printElem(int& elem)

{

cout << elem << endl;

}

int main()

{

int ia[]={0,1,2,3,4,5,6};

for_each(ia,ia+7,printElem);//输出

int ib[]={7,8,9,10,11,12,13};

vector<int> iv(ib,ib+7);

for_each(iv.begin(),iv.end(),plus2<int>());//更改元素

for_each(iv.begin(),iv.end(),printElem);//输出

return 0;

}

二，find算法

int *find(int *begin，int *end，int value)

前闭后合的区间 begin，end中，查找value如果查找到了就返回第一个符合条件的元素，否则返回end指针

[html] view
plain copy

#include <iostream>

#include <algorithm>

using namespace std;

void printElem(int& elem)

{

cout << elem << endl;

}

int main()

{

int ia[]={0,1,2,3,4,5,6};

int *i= find(ia,ia+7,9);//在整个数组中查找元素 9

int *j= find(ia,ia+7,3);//在整个数组中查找元素 3

int *end=ia+7;//数组最后位置

if(i == end)

cout<<"没有找到元素 9"<<endl;

else

cout<<"找到元素9"<<endl;

if(j == end)

cout<<"没有找到元素 3"<<endl;

else

cout<<"找到元素"<<*j<<endl;

return 0;

}

三，数值算法

包含在<numeric>头文件中

[html] view
plain copy

#include <iostream>

#include <numeric> //数值算法

#include <vector>

#include <functional>

#include <iterator>

#include <math.h>

using namespace std;

int main()

{

int ia[]={1,2,3,4,5};

vector<int> iv(ia,ia+5);

cout<<accumulate(iv.begin(),iv.end(),0)<<endl; //累加 初值为0

cout<<accumulate(iv.begin(),iv.end(),0,minus<int>())<<endl; //累加 符号位负

cout<<inner_product(iv.begin(),iv.end(),iv.begin(),10)<<endl;//两个数组内积 初值为10

cout<<inner_product(iv.begin(),iv.end(),iv.begin(),10,minus<int>(),plus<int>())<<endl;//10-(1+1)-(2+2)

ostream_iterator<int> oite(cout," ");//迭代器绑定到cout上作为输出使用

partial_sum(iv.begin(),iv.end(),oite);//依次输出前n个数的和

cout<<endl;

partial_sum(iv.begin(),iv.end(),oite,minus<int>());//依次输出第一个数减去（除第一个数外到当前数的和）

cout<<endl;

adjacent_difference(iv.begin(),iv.end(),oite); //输出相邻元素差值 前面-后面

cout<<endl;

adjacent_difference(iv.begin(),iv.end(),oite,plus<int>()); //输出相邻元素差值 前面+后面 。前面更改影响后面元素

cout<<endl;

cout<<pow(10,3)<<endl; // 平方

/* VC 不支持 只有安装了才SGI STL支持

int n=3;

iota(iv.begin(),iv.end(),n);//在指定区间填入n n+1 n+2

for(int i=0;i<iv.size();++i)

cout<<iv[i]<<" ";

*/

return 0;

}

四，基本算法

[html] view
plain copy

#include <iostream>

#include <algorithm>

#include <vector>

using namespace std;

template<typename T>

struct display

{

void operator()(const T &x)const

{

cout<<x<<" ";

}

};

int main()

{

int ia[]={0,1,2,3,4,5,6,7,8};

vector<int> iv1(ia,ia+5);

vector<int> iv2(ia,ia+9);

pair<vector<int>::iterator,vector<int>::iterator> pa;

pa=mismatch(iv1.begin(),iv1.end(),iv2.begin());

cout<<"两个数组不同点--第一个数组点:"<<*(pa.first)<<endl; //这样写很危险，应该判断是否到达end

cout<<"两个数组不同点--第二个数组点:"<<*(pa.second)<<endl;

//更改之后

if(pa.first == iv1.end())

cout<<"第一个数组与第二个数组匹配"<<endl;

cout<<equal(iv1.begin(),iv1.end(),iv2.begin())<<endl;// 1 表示 相等，因为只比较跟 iv1长度大小的数组

cout<<equal(iv1.begin(),iv1.end(),&ia[3])<<endl;// 0 表示 不相等

cout<<equal(iv1.begin(),iv1.end(),&ia[3],less<int>())<<endl;// 1 表示 前者小于后者

fill(iv1.begin(),iv1.end(),9);//将iv1区间内填满 9

for_each(iv1.begin(),iv1.end(),display<int>());

cout<<endl;

fill_n(iv1.begin(),3,6);//从iv1区间开始填 3个6

for_each(iv1.begin(),iv1.end(),display<int>());

cout<<endl;

vector<int>::iterator ite1=iv1.begin();

vector<int>::iterator ite2=ite1;

advance(ite2,3);//向前跳3个

iter_swap(ite1,ite2);//交换迭代器指向的元素

for_each(iv1.begin(),iv1.end(),display<int>());

cout<<"\nmax:"<<max(*ite1,*ite2)<<endl;

cout<<"min:"<<min(*ite1,*ite2)<<endl;

swap(*ite1,*ite2);

for_each(iv1.begin(),iv1.end(),display<int>());

cout<<endl;

string stra1[]={"a","b","c"};

string stra2[]={"d","e","f"};

cout<<lexicographical_compare(stra1,stra1+2,stra2,stra2+2)<<endl;//按照字典序 前者小于后者

cout<<lexicographical_compare(stra1,stra1+2,stra2,stra2+2,greater<string>())<<endl;//按照字典序 前者不大于后者

return 0;

}

五，copy（）对不同容器复制；关于输出区间与输入区间重叠的讨论

[html] view
plain copy

#include <iostream>

#include <algorithm>

#include <deque>

using namespace std;

template<class T>

struct display

{

void operator()(const T &x)const

{

cout<<x<<" ";

}

};

int main()

{

//以下复制区间没有问题

int ia1[]={0,1,2,3,4,5,6,7,8};

copy(ia1+2,ia1+7,ia1);//将下标2-6复制给 1-5

for_each(ia1,ia1+9,display<int>()); //2,3,4,5,6,5,6,7,8

cout<<endl;

//输出区间的起点与输入区间重叠，可能会有问题。但本例copy采用memmove()执行实际复制操作

int ia2[]={0,1,2,3,4,5,6,7,8};

copy(ia2+2,ia2+7,ia2+4);//将下标2-6复制给 4-8

for_each(ia2,ia2+9,display<int>()); //0,1,2,3,2,3,4,5,6

cout<<endl;

//以下复制区间没有问题

int ia3[]={0,1,2,3,4,5,6,7,8};

deque<int> id(ia3,ia3+9);

deque<int>::iterator first=id.begin();

deque<int>::iterator last=id.end();

deque<int>::iterator result=id.begin();

++++first;

cout<<*first<<endl;

----last;

cout<<*last<<endl;

cout<<*result<<endl;

copy(first,last,result);

for_each(id.begin(),id.end(),display<int>());//2,3,4,5,6,5,6,7,8

cout<<endl;

//以下复制区间存在问题，由于实际复制没有采用memove()，结果错误

int ia4[]={0,1,2,3,4,5,6,7,8};

deque<int> ide(ia4,ia4+9);

deque<int>::iterator first1=ide.begin();

deque<int>::iterator last1=ide.end();

deque<int>::iterator result1=ide.begin();

advance(result1,4);//注意这里跟上面不一样

++++first1;

cout<<*first1<<endl;

----last1;

cout<<*last1<<endl;

cout<<*result1<<endl;

copy(first1,last1,result1);

for_each(ide.begin(),ide.end(),display<int>());// 0,1,2,3,2,3,2,3,2不是预期的 0,1,2,3,2,3,4,5,6

cout<<endl;

return 0;

}

【注意】如果以vector 容器替代deque容器则每种情况都正确，因为vector迭代器其实是个源生指针，调用的copy()算法以mommove()执行实际复制。

copy_backward(first，last，result); //逆向复制，将迭代器first - last位置的元素逆向复制到 从result-1开始的逆向区间

补充：

原型：void *memmove( void * dest, const void * src, size_t count );

　　用法：#include <string.h>或#include <memory.h>

　　功能：由src所指内存区域复制count个字节到dest所指内存区域。

　　说明：src和dest所指内存区域可以重叠，但复制后dest内容会被更改。函数返回指向dest的指针。采取先拷贝再复制的方式，有效解决了dest和src区域重叠问题

　　相关函数：memset、memcpy、strcpy 参考博文http://blog.csdn.net/tianshuai11/article/details/7624419

实例

　　

[html] view
plain copy

#include <stdio.h>

#include <string.h>

int main()

{

　 char s[]="Golden Global View";

memmove(s,s+7,strlen(s)+1-7);

printf("%s",s);

　　

　 return 0;

}

六，Set方法

[html] view
plain copy

#include <iostream>

#include <set>

#include <algorithm>

#include <iterator>

using namespace std;

template <class T>

struct display

{

void operator()(const T &x)

{

cout<<x<<" ";

}

};

int main()

{

int ia1[]={1,3,5,7,9,11};

int ia2[]={1,1,2,3,5,8,13};

multiset<int> s1(ia1,ia1+6);

multiset<int> s2(ia2,ia2+7);

for_each(s1.begin(),s1.end(),display<int>());

cout<<endl;

for_each(s2.begin(),s2.end(),display<int>());

cout<<endl;

multiset<int>::iterator first1 = s1.begin();

multiset<int>::iterator last1 = s1.end();

multiset<int>::iterator first2 = s2.begin();

multiset<int>::iterator last2 = s2.end();

cout<<"union of s1 and s2: ";

//两个集合合并，相同元素个数取 max(m,n)。

set_union(first1,last1,first2,last2,ostream_iterator<int>(cout," "));

cout<<endl;

first1=s1.begin();

first2=s2.begin();

cout<<"Intersection of s1 and s2: ";

//两个集合交集，相同元素个数取 min(m,n).

set_intersection(first1,last1,first2,last2,ostream_iterator<int>(cout," "));

cout<<endl;

first1=s1.begin();

first2=s2.begin();

cout<<"Intersection of s1 and s2: ";

//两个集合差集 就是去掉S1中 的s2

set_difference(first1,last1,first2,last2,ostream_iterator<int>(cout," "));

cout<<endl;

first1=s1.begin();

first2=s2.begin();

cout<<"Intersection of s1 and s2: ";

//两个集合对称差集：就是取两个集合互相没有的元素 。两个排序区间，元素相等指针后移，不等输出小的并前进

//相同元素的个数 abs(m-n)

set_symmetric_difference(first1,last1,first2,last2,ostream_iterator<int>(cout," "));

cout<<endl;

return 0;

}

七，其他算法（运算逻辑相对单纯的算法）

[html] view
plain copy

#include <iostream>

#include <algorithm>

#include <vector>

#include <functional>

#include <vector>

using namespace std;

template <class T>

struct display

{

void operator()(const T &x)const

{

cout<<x<<" ";

}

};

struct even

{

bool operator()(int x)const

{

return x%2?false:true;

}

};

class even_by_two

{

private:

static int _x; //注意静态变量

public:

int operator()()const

{

return _x+=2;

}

};

int even_by_two::_x=0;

int main()

{

int ia[]={0,1,2,3,4,5,6,6,6,7,8};

vector<int> iv(ia,ia+sizeof(ia)/sizeof(int));

//找出iv之中相邻元素值相等的第一个元素

cout<<*adjacent_find(iv.begin(),iv.end())<<endl;

cout<<*adjacent_find(iv.begin(),iv.end(),equal_to<int>())<<endl; //仿函数

cout<<count(iv.begin(),iv.end(),6)<<endl;//统计6的个数

cout<<count_if(iv.begin(),iv.end(),bind2nd(less<int>(),7))<<endl;//统计小于7的元素的个数 :9个

cout<<*find(iv.begin(),iv.end(),4)<<endl; //返回元素为4的元素的下标位置

cout<<*find_if(iv.begin(),iv.end(),bind2nd(greater<int>(),2))<<endl; //返回大于2的第一个元素的位置：3

vector<int> iv2(ia+6,ia+8);//6 6

for(int i=0;i<iv2.size();++i)

cout<<iv2[i]<<" ";

cout<<endl;

//返回iv序列中 iv2序列 出现的最后一个位置（再往后三个位置的值）：8

cout<<"find_end:"<<*(find_end(iv.begin(),iv.end(),iv2.begin(),iv2.end())+3)<<endl;

//返回iv序列中 iv2序列 出现的最后一个位置（再往后三个位置的值）：7

cout<<"find_first_of:"<<*(find_first_of(iv.begin(),iv.end(),iv2.begin(),iv2.end())+3)<<endl;

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;

//遍历整个iv2区间并执行 even_by_two操作

generate(iv2.begin(),iv2.end(),even_by_two());

for_each(iv2.begin(),iv2.end(),display<int>());

cout<<endl;

//遍历区间（给出起点和长度），对每个遍历元素执行even_by_two操作

generate_n(iv.begin(),3,even_by_two());

for_each(iv.begin(),iv.end(),display<int>()); //由于_X是static 所以接着 增长

cout<<endl;

//删除元素6 尾端可能有残余数据

remove(iv.begin(),iv.end(),6);

for_each(iv.begin(),iv.end(),display<int>()); //由于_X是static 所以接着 增长

cout<<endl; //8 10 3 4 5 7 8 6 6 7 8 (最后四个是残留数据)

//去除value 然后将一个容器的元素复制到另一个 容器。仍然可能有残留元素

vector<int> iv3(12);//重新申请空间

remove_copy(iv.begin(),iv.end(),iv3.begin(),6);

for_each(iv3.begin(),iv3.end(),display<int>()); //由于_X是static 所以接着 增长

cout<<endl; //8 10 3 4 5 7 8 7 8 0 0 （最后两个是残留元素）

//将小于6的元素 "删除" iv 此时为 8 10 3 4 5 7 8 6 6 7 8

remove_if(iv.begin(),iv.end(),bind2nd(less<int>,6));

for_each(iv1.begin(),iv1.end(),display<int>()); //由于_X是static 所以接着 增长

cout<<endl; //8 10 7 8 6 6 7 8 6 7 8 (最后三个是残留元素)

//将小于7的元素 "删除" iv3元素：8 10 3 4 5 7 8 7 8 0 0 （最后两个是残留元素）

remove_copy_if(iv.begin(),iv.end(),iv3.begin(),bind2nd(less<int>,7));

for_each(iv3.begin(),iv3.end(),display<int>()); //由于_X是static 所以接着 增长

cout<<endl; //8 10 7 8 7 8 7 8 8 0 0（最后三个残留元素）

return 0;

}

第二段算法示例：

[html] view
plain copy

#include <iostream>

#include <algorithm>

#include <vector>

#include <functional>

using namespace std;

template <class T>

struct display

{

void operator()(const T &x)const

{

cout<<x<<" ";

}

};

int main()

{

int ia[]={8,10,7,8,6,6,7,8,6,7,8};

vector<int> iv(ia,ia+sizeof(ia)/sizeof(int));

//将容器中6 替换为 3

replace(iv.begin(),iv.end(),6,3);

for_each(iv.begin(),iv.end(),display<int>()); //由于_X是static 所以接着 增长

cout<<endl; //iv:8 10 7 8 3 3 7 8 3 7 8

vector<int> iv2(12);

//将容器中3 替换为 5 放入另一个容器

replace_copy(iv.begin(),iv.end(),iv2.begin(),3,5);

for_each(iv2.begin(),iv2.end(),display<int>()); //由于_X是static 所以接着 增长

cout<<endl; //iv2:8 10 7 8 5 5 7 8 5 7 8 0（最后y一个残留元素）

//将容器中小于 5 替换为 2

replace_if(iv.begin(),iv.end(),bind2nd(less<int>(),5),2);

for_each(iv.begin(),iv.end(),display<int>()); //由于_X是static 所以接着 增长

cout<<endl; //iv:8 10 7 8 2 5 7 8 2 7 8

//将容器中小于 5 替换为 2

replace_copy_if(iv.begin(),iv.end(),iv2.begin(),bind2nd(equal_to<int>(),8),9);

for_each(iv2.begin(),iv2.end(),display<int>()); //由于_X是static 所以接着 增长

cout<<endl; //iv2:9 10 7 8 2 5 7 9 2 7 8 0(最后一个残留元素)

//逆向重排每一个元素 (倒置)

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

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl; //iv:8 7 2 8 7 5 2 8 7 10 8

//逆向重排每一个元素 (倒置)

reverse_copy(iv.begin(),iv.end(),iv2.begin());

for_each(iv2.begin(),iv2.end(),display<int>());

cout<<endl; //iv2:8 10 7 8 2 5 7 8 2 7 8 0 (最后一个残留元素)

// 互换元素 [bigin,middle) [middle,end)

rotate(iv.begin(),iv.begin()+4,iv.end());

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;//iv:7 2 2 8 7 10 8 8 7 2 8

// 互换元素 [bigin,middle) [middle,end)

rotate_copy(iv.begin(),iv.begin()+5,iv.end(),iv2.begin());

for_each(iv2.begin(),iv2.end(),display<int>());

cout<<endl;//iv2:10 8 8 7 2 8 7 2 2 8 7 0 (最后一个是残留元素)

//在iv中查找 子序列 2 8 第一次出现的位置的元素

int ia2[3]={2,8};

vector<int> iv3(ia2,ia2+2);

cout<<*search(iv.begin(),iv.end(),iv3.begin(),iv3.end())<<endl; //2

//在iv中查找 2个8 出现的第一个位置的元素

cout<<*search_n(iv.begin(),iv.end(),2,8)<<endl; //8

//在iv中查找 3个小于8 出现的第一个位置的元素

cout<<*search_n(iv.begin(),iv.end(),3,8,less<int>())<<endl; //7

swap_ranges(iv3.begin(),iv3.end(),iv.begin());

cout<<"iv:";

for_each(iv.begin(),iv.end(),display<int>());//iv:2 8 2 8 7 10 8 8 7 2 8

cout<<endl;

cout<<"iv3:";

for_each(iv3.begin(),iv3.end(),display<int>()); //iv3: 7 2

cout<<endl;

//全部减2

transform(iv.begin(),iv.end(),iv.begin(),bind2nd(minus<int>(),2));

for_each(iv.begin(),iv.end(),display<int>());//0 6 0 6 5 8 6 6 5 0 6

cout<<endl;

//两个区间元素相加然后放到 iv上

transform(iv.begin(),iv.end(),iv.begin(),iv.begin(),plus<int>());

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl; //0 12 0 12 10 16 12 12 10 0 12

return 0;

}

第三段算法示例：

[html] view
plain copy

#include <iostream>

#include <algorithm>

#include <vector>

#include <functional>

using namespace std;

template <class T>

struct display

{

void operator()(const T &x)const

{

cout<<x<<" ";

}

};

struct even

{

bool operator()(int x)const

{

return x%2?false:true;

}

};

int main()

{

int ia[]={0,1,2,3,4,5,6,6,6,7,8};

vector<int> iv(ia,ia+sizeof(ia)/sizeof(int));

vector<int> iv2(ia+4,ia+8);//4 5 6 6

vector<int> iv3(15);

cout<<*max_element(iv.begin(),iv.end())<<endl;

cout<<*min_element(iv.begin(),iv.end())<<endl;

//判断iv2中元素是否都出现在 iv中

cout<<includes(iv.begin(),iv.end(),iv2.begin(),iv2.end())<<endl;

//iv 和iv2合并到iv3中

merge(iv.begin(),iv.end(),iv2.begin(),iv2.end(),iv3.begin());

for_each(iv3.begin(),iv3.end(),display<int>());

cout<<endl;

//符合条件的 放到前面，不符合条件的放到后面

partition(iv3.begin(),iv3.end(),even());

for_each(iv3.begin(),iv3.end(),display<int>());

cout<<endl;

//去除连续并且重复的元素

unique(iv.begin(),iv.end());

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;

//去除连续并且重复的元素

unique_copy(iv.begin(),iv.end(),iv3.begin());

for_each(iv3.begin(),iv3.end(),display<int>());

cout<<endl;

return 0;

}

八，复杂算法示例（解释在源码中）

[html] view
plain copy

#include <iostream>

#include <vector>

#include <functional>

#include <algorithm>

using namespace std;

struct even //是否是奇数

{

bool operator()(int x)const

{

return x%2?false:true;

}

};

template<class T>

struct display

{

void operator()(T &x)const

{

cout<<x<<" ";

}

};

int main()

{

int ia[] = {12,17,20,22,23,30,33,40};

vector<int> iv(ia,ia+sizeof(ia)/sizeof(int));

//返回可以插入的第一个位置

cout<<*lower_bound(iv.begin(),iv.end(),21)<<endl; //22

cout<<*upper_bound(iv.begin(),iv.end(),21)<<endl; //22

//返回可以插入的最后一个位置

cout<<*lower_bound(iv.begin(),iv.end(),22)<<endl; //22

cout<<*upper_bound(iv.begin(),iv.end(),22)<<endl; //23

//二分查找某个元素，返回是否找到

cout<<binary_search(iv.begin(),iv.end(),33)<<endl; //1

cout<<binary_search(iv.begin(),iv.end(),34)<<endl; //0

//生成下一个排列组合（字典序）

next_permutation(iv.begin(),iv.end());

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;

prev_permutation(iv.begin(),iv.end());

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;

//打乱顺序

random_shuffle(iv.begin(),iv.end());

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;

//找出最小的4个元素 放在前四个 后面顺序不一定有序

partial_sort(iv.begin(),iv.begin()+4,iv.end());

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;

//排序（缺省为递增排序）

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

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;

//排序（设置为递减）

sort(iv.begin(),iv.end(),greater<int>());

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;

iv.push_back(22);

iv.push_back(30);

iv.push_back(17);

//排序并保持原相对位置

stable_sort(iv.begin(),iv.end());

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;//12 17 17 20 22 22 23 30 30 33 40

pair<vector<int>::iterator,vector<int>::iterator> pairIte;

//返回等于22的一个小区间

pairIte = equal_range(iv.begin(),iv.end(),22);

cout<<*(pairIte.first)<<endl;//lowerbound 22

cout<<*(pairIte.second)<<endl; //upperbound 23

//这里返回一个空区间

pairIte = equal_range(iv.begin(),iv.end(),25);

cout<<*(pairIte.first)<<endl;//lowerbound 30

cout<<*(pairIte.second)<<endl; //upperbound 30

//打乱顺序

random_shuffle(iv.begin(),iv.end());

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;

//将小于iv.begin+5的放到左边

nth_element(iv.begin(),iv.begin()+5,iv.end());

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;

//将小于iv.begin+5的放到右边

nth_element(iv.begin(),iv.begin()+5,iv.end(),greater<int>());

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;

//排序

stable_sort(iv.begin(),iv.end(),even());

for_each(iv.begin(),iv.end(),display<int>());

cout<<endl;

return 0;

}

参考文章：点击打开链接